Wiki du LAMA (UMR 5127) - Contributions [fr]

Apprentissage automatique

2020-05-19T08:22:55Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptables. 
[[Fichier:Precision.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Fichier:Precision.png

2020-05-19T08:22:16Z

El-huissier :

Apprentissage automatique

2020-05-18T09:18:28Z

El-huissier : /* Réseau */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptables. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:16:51Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptables. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:16:25Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptables. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:16:04Z

El-huissier : /* Préliminaires */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:15:13Z

El-huissier : /* Descente de gradient */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:14:52Z

El-huissier : /* Descente de gradient */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:14:27Z

El-huissier : /* Descente de gradient */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:14:21Z

El-huissier : /* Descente de gradient */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats (ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur de η est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:09:17Z

El-huissier : /* Les neurones sigmoïdes */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égal à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:08:25Z

El-huissier : /* Perceptrons */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaires (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T09:07:54Z

El-huissier : /* Deep Learning */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelée le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T08:39:19Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreurs ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T08:39:01Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T08:38:30Z

El-huissier : /* Réseau */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T08:38:10Z

El-huissier : /* Application */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 
 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T08:37:00Z

El-huissier :

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montrent les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peut entraîner un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait, quoi qu'il arrive pour éviter les erreurs, et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problèmes, en effet, comme le perceptron, il possède un poids et un biais par entrée; cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif d'un neurone n'est pas de rester seul mais de former un réseau, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme son nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante. Cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien y en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions dû obtenir. L'objectif est de minimiser la fonction en trouvant les poids et biais correspondants.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais adéquats(ici matérialisés par v1,v2,etc en fonction du nombre de dimension), on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation, cela nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la valeur est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur. La fonction de coût fonctionne avec les résultats. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste, en partant du résultat, à trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant l'erreur vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cet algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître des chiffres manuscrits. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. 
On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiples fonctions, qui vont définir le réseau. 
On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, on la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. 
Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur ne seraient pas acceptable. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T07:48:47Z

El-huissier : /* Préliminaires */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste à partir du résultat, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Data_import.png]]
 

=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Fichier:Data import.png

2020-05-18T07:47:59Z

El-huissier :

Apprentissage automatique

2020-05-18T07:45:47Z

El-huissier :

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un réseau performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports sont des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ces problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrées contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sorties contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste à partir du résultat, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T07:41:34Z

El-huissier : /* Entraînement */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époques d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T07:40:51Z

El-huissier : /* Backpropagation */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quels poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T07:40:08Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dit précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la nôtre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Fichier:Creation set.png

2020-05-18T07:37:00Z

El-huissier : El-huissier a téléversé une nouvelle version de Fichier:Creation set.png

Fichier:Creation set.png

2020-05-18T07:35:11Z

El-huissier : El-huissier a téléversé une nouvelle version de Fichier:Creation set.png

Apprentissage automatique

2020-05-18T07:09:06Z

El-huissier : /* Backpropagation */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique, consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T06:52:08Z

El-huissier :

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment optimiser leur vitesse pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T06:51:37Z

El-huissier :

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et par la suite un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-18T06:51:02Z

El-huissier : /* Neurones */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ces supports ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:47:04Z

El-huissier : /* Réseau */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée ,y la sortie et w et b respectivement les poids et biais. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:46:20Z

El-huissier : /* Réseau */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on définit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 

=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:44:41Z

El-huissier : /* Réseaux de neurones */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux, les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:43:25Z

El-huissier : /* Neurones */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour qu'un apprentissage ait lieu il faut un support qui peut supporter des changements. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:42:19Z

El-huissier :

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon performant.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour que cet apprentissage ait lieu, il faut un support à améliorer. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

VISI201 CMI : visite de laboratoire

2020-05-17T15:36:12Z

El-huissier : /* Sujets réalisés (2019-2020) */

* Cours du semestre 2 du parcours CMI Informatique (licence INFO).

* Responsable pour 2019--2020: Jacques-Olivier Lachaud
* Responsable pour 2018--2019: Jacques-Olivier Lachaud
* Responsable pour 2017--2018: Jacques-Olivier Lachaud
* Responsable pour 2016--2017: Jacques-Olivier Lachaud

= Descriptif =

L'objectif du module est de faire découvrir les laboratoires, le monde de la recherche et les enseignants-chercheurs et chercheurs, ainsi que la réflexion scientifique. Cela se fait de deux manières.

D'abord, une partie de ce module consiste à assister à des séminaires dédiés aux étudiants CMI Informatique et Mathématique (1 fois par mois, les jeudi après-midi). [[http://www.lama.univ-savoie.fr/index.php?use=seminaires&&lang=fr&equipe=cmi&annee=1&lang=fr Planning des séminaires CMI]]

Ces séminaires "grand public" portent sur des sujets variées en informatique et mathématiques.

Les étudiants choisissent ensuite d'approfondir un sujet proposé par les enseignants, ou un sujet motivé de leur choix (en accord avec le responsable du module). Ce travail se fait en interaction avec un tuteur académique (5-6 contacts au moins). Ce travail personnel tuteuré donne lieu à la rédaction d'une synthèse sur le sujet sous forme d'une page wiki/web, ainsi que d'un mini-exposé.

= Sujets réalisés (2019-2020) =

* Compression et transformée de Burrow-Wheeler, Simon Léonard (Tuteur : Pierre Hyvernat)
* Backtracking, Simon Pichenot (Tuteur : Pierre Hyvernat)
* Transfert de couleur (version 2), Florian Dufaure (Tuteur : Jacques-Olivier Lachaud)
* [[Génération fractale de terrains]], Hugo Rey (Tuteur : Jacques-Olivier Lachaud)
* Architectures Orientées Micro-Services, Romain Negro (David Télisson)
* [[Apprentissage automatique]], Evan L'Huissier (Tuteur : Tom Hirschowitz)
* [[Algorithmes probabilistes/déterministes pour tester la primalité d'un entier]], Juliette Neyrat (Tuteur : Sébastien Tavenas)
* [[Base de données orientées Graphe et similarité]], Romain Pajean (Gérald Cavallini)
* [[Modèles d'évolution de populations]], Théo Guesdon (Tuteur : Jimmy Garnier)

= Sujets proposés (2019-2020) =

* Compression et transformée de Burrow-Wheeler
* Backtracking
* Transfert de couleur (version 2)
* Génération fractale de terrains
* Architectures Orientées Micro-Services
* Apprentissage automatique
* Algorithmes probabilistes/déterministes pour tester la primalité d'un entier
* Base de données orientées Graphe, similarité et modèles prédictifs

== Compression et transformée de Burrow-Wheeler ==

* Tuteur : Pierre Hyvernat
* Résumé : La transformée de Burrow-Wheeler est l'étape clé de l'algorithme de compression bzip2. C'est une transformation de texte (suite d'octet) qui ne modifie pas la taille, mais ajoute suffisamment de motifs redondants pour améliorer un autre algorithme de compression (algorithme de Huffman dans le cas de bzip2)
* Objectif : L'objectif est de comprendre le fonctionnement de cette transformation (et de son inverse) et d'implémenter une version naïve de l'algorithme de compression / décompression et de tester sur quelques exemples. Les améliorations de l'algorithme seront ensuite abordées.
* Liens : Burrows, Michael; Wheeler, David J. (1994), A block sorting lossless data compression algorithm, Technical Report 124, Digital Equipment Corporation [[https://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-124.pdf PDF]]

== Backtracking ==

* Tuteur : Pierre Hyvernat
* Résumé et objectif : La notion de "backtracking" est fondamentale en algorithmique : il s'agit essentiellement de tester des solutions partielles à un problème, en revenant en arrière dès qu'une incohérence est découverte. Le point de départ sera le fascicule 4.5b de D. Knuth "Introduction to backtracking" et permettra de se familiariser avec les concepts, la terminology et des exemples, qu'il faudra implémenter. Une suite possible sera la notion de réduction de problèmes et l'algorithme-X qui permet de "factoriser" de nombreux problèmes de backtracking en un seul algorithme.
* Liens : D. Knuth, "the art of computer programming introduction to backtracking" [[https://www-cs-faculty.stanford.edu/~knuth/fasc5b.ps.gz PS]]

== Transfert de couleur (version 2) ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: Le transfert de couleurs de l'image Y vers l'image X consiste à repeindre "au mieux" l'image X avec la palette de couleurs de l'image Y. L'image repeinte X' a alors les mêmes couleurs que l'image Y (mais les pixels ne sont pas répartis pareils). Voir l'exemple de transfert ci-dessous. Il existe plusieurs techniques de transfert de couleurs, mais nous étudierons une technique basée sur le transport optimal. Comme c'est un problème assez difficile dans le cas général, nous étudierons une variante dite par coupe 1D, qui simplifiera considérablement le problème de transport.
{| class="wikitable alternance center"
|+ Transfert de couleur
|----
! scope="col" | Input !! scope="col" | Output
|----
| [[Fichier:horseshoe.jpg|200px]] || [[Fichier:horseshoe-fjord-n40.jpg|200px]]
|----
| [[Fichier:fjord.jpg|200px]] || [[Fichier:fjord-horseshoe-n40.jpg|200px]]
|}
* Objectifs:
*# Comprendre la version 1 fait par [[https://www.lama.univ-savoie.fr/mediawiki/index.php/Transport_optimal_par_coupe_1D_et_transfert_de_couleurs_entre_images Lucas Chardonnet]], comprendre les qualités et limites de l'approche (sur quelle type d'image ça marche assez bien par exemple)
*# Adapter l'algorithme pour qu'il puisse traiter des images de tailles différentes
*# Réécrire le code en utilisant la bibliothèque python NUMPY pour accélérer les calculs
*# Changer les espaces de couleurs utilisés: RGB ne convient pas très bien pour mesurer le coût du transport. Transformer le code pour qu'il puisse utiliser plutôt l'espace [[https://fr.wikipedia.org/wiki/L*a*b*_CIE_1976 L*a*b*]] mieux adapté pour calculer des distances entre couleurs.
* Liens:
** la page de [[https://www.lama.univ-savoie.fr/mediawiki/index.php/Transport_optimal_par_coupe_1D_et_transfert_de_couleurs_entre_images Lucas Chardonnet]]
** [[https://en.wikipedia.org/wiki/Color_mapping Transfert de couleur Wikipedia]]
** [[https://hal.archives-ouvertes.fr/tel-01246096/file/hdr_hal2.pdf Habilitation de N. Papadakis]] (regardez les images plutôt).

== Génération fractale de terrains ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: La génération procédurale de terrain est très utilisée en modélisation 3D et dans les jeux vidéos, afin de générer rapidement des paysages pseudo-réalistes que l'on étoffera ensuite de façon plus manuelle. On propose d'étudier et d'implémenter un algorithme classique, dit "algorithme Diamant-Carré". Cet algorithme récursif permet de générer une carte d'élévation. Selon les paramètres données, le résultat peut ressembler aux cartes d'altitude de haute montagne ou des collines plus douces.
{| class="wikitable alternance center"
|+ Génération fractale de terrain par algorithme diamand carré
|----
! scope="col" | Elévations générées !! scope="col" | Colorisation !! scope="col" | Visualisation 3D
|----
| [[Fichier:Diamond-Square_texture.png|200px]] || [[Fichier:Diamond-Square_heightmap.png|200px]] || [[Fichier:Terragen.jpg|200px]]
|}

* Objectifs:
*# Comprendre et implémenter l'algorithme Diamant-Carré
*# Comprendre comment paramétrer cet algorithme pour qu'il génère des montagnes bien abrupte à haute altitude ou des collines à basse altitude.
*# Fabriquer une image de couleur/texture qui va associer des couleurs aux altitudes générées (e.g. forcer du bleu sous l'altitude zero, ajouter de la neige, des lacs, de la forêt)
*# Générer un fichier 3D (par exemple OBJ) à partir de ces deux images (l'image des hauteurs et l'image des couleurs) pour pouvoir faire de beau rendu 3D (sous blender par exemple)
* Liens:
** La page [[https://fr.wikipedia.org/wiki/Algorithme_Diamant-Carr%C3%A9 Wikipedia]] de l'algorithme
** La page [[https://en.wikipedia.org/wiki/Wavefront_.obj_file Wikipedia]] du format OBJ

== Architectures Orientées Micro-Services ==

* Tuteur : David Télisson
* Résumé : Les architectures des applications logicielles distribuées de grandes envergures ont évolué à partir du début des années 2000, d’une application molithique déployée sur un serveur d’application (JEE, TomCat, etc.) vers des solutions fortement répartis déployées sous formes de services. On parle alors d’architectures orientées services qui se traduisent par le développement et le déploiement de services logiciels interrogeables via des protocoles dédiés (par exemple SOAP) et des API (REST). Cette tendance, corrélée aux nouvelles méthodes de management des projets informatiques (méthodes agiles, intégration continue, DevOps1), s’est accentué ces dernières années et a fait émergé un « nouveau » paradigme : le micro-service. Plusieurs aspects caractérisent un micro-service :
** fonctionnalité unique
** flexibilité technologie
** équipe de développement réduite
** déploiement ciblé
** support de la montée en charge (scalabilité)
** tests facilités et intégrés au processus de développement (TDD2)
* Objectifs du projet :
*# Etudier et comprendre les concepts liés aux micro-services (API, conteneurisation, framework, etc.)
*# Implémentez un PoC (proof of concept) qui démontre qu’une application peut se construire dynamiquement par agrégation de micro-services développés avec des langages différents (Python, JS et Java), déployés sur des plateformes différentes (Django, Node et Glassfish) et disponibles sous formes de conteneurs dans le cloud (Azure)
*# Livrable attendu : un tutoriel « à la OpenClassRooms »
* Liens pour démarrer :
** https://mbaron.developpez.com/cours/microservices/introduction-generalites
** https://openclassrooms.com/fr/courses/4668056-construisez-des-microservices

== Apprentissage automatique ==

* Tuteur : Tom Hirschowitz
* Résumé : L'apprentissage automatique est un ensemble de techniques algorithmiques visant à écrire des programmes qui améliorent leurs performances au cours du temps. Le sujet consiste en une initiation à cette idée par l'exemple, à base de ressources telles que https://colah.github.io/posts/2015-08-Backprop et http://neuralnetworksanddeeplearning.com .

== Algorithmes probabilistes/déterministes pour tester la primalité d'un entier ==

* Tuteur : Sébastien Tavenas
* Pouvoir tester si un entier est un nombre premier semble être une brique de base si l'on souhaite faire de l'arithmétique sur un ordinateur. Le crible d'Érathostène enseigné dans les petites classes se montre beaucoup trop lent en pratique. L'algorithme probabiliste utilisé le plus rapide est le test de Fermat. Or, si on regarde les algorithmes des librairies "génériques", on peut s'apercevoir que la fonction 'mpz_probab_prime_p' de la librairie 'gmp' sur c++ utilise un test probabiliste de Miller-Rabin, la fonction 'isPrime' de la classe 'Prime' dans java utilise aussi un test de Miller-Rabin mais qui est déterminisé, alors que la fonction 'isprime' de la librairie 'sympy' dans python effectue un test de Miller-Rabin si l'entier est plus petit que 2^64 et un test BPSW fort si l'entier est plus grand. Ainsi, une fonction déjà implémentée de test de primalité peut se tromper ou non, être instantanée ou moins. Que dire alors de l'algorithme polynomial déterministe et toujours correct proposé par AKS?
* Objectifs :
*# Comprendre quelques tests de primalité et comment l'aléatoire est utilisé dans ces algorithmes
*# Comprendre la notion de nombre pseudopremier qui explique, entre autre, quand il vaut mieux utiliser le test de Fermat ou celui de Miller-Rabin
*# Programmer quelques uns des ces tests et les comparer
*# Essayer de dérandomiser ces tests à l'aide de hitting-sets précalculés

* Liens pour commencer
** [[https://en.wikipedia.org/wiki/Primality_test Tests de primalité]]

== Base de données orientées Graphe, similarité et modèles prédictifs ==

* Tuteur : Gérald Cavallini
* Résumé : Avec l’avènement du BigDatas, dans bien des cas le choix d’un produit, d’un média, d’un voyage ... ne peut plus être direct. Il s’appuie sur des systèmes de recommandations. L’importance financière de ces systèmes est énorme Amazon estime à 30% les ventes supplémentaires dues à son système de recommandation. Ces systèmes s’appuient sur des calculs statistiques et des algorithmes de recherche de similarité. Ces algorithmes expriment la distance entre des objets, ce qui permet par exemple d’identifier des utilisateurs(consommateurs, électeur ...) similaire et de recommander leurs choix.
* Objectifs :
*# Mettre en œuvre différents algorithmes de recherche de similarité ( similarité de Jaquard, similarité cosinus...) dans une base de donnée orientées Graphe Neo4j.
*# Proposer un système de recommandation de film à partir de la base MovieLens (Notation de films par des utilisateurs).
*# Proposer un une validation du modèle prédictif.
* Liens pour commencer
** https://fr.wikipedia.org/wiki/Indice_et_distance_de_Jaccard
** https://www.machinelearningplus.com/nlp/cosine-similarity/
** https://neo4j.com/
** https://movielens.org/

[[Fichier:Neo4j.jpg|400px]]

= Sujets réalisés (2018-2019) =

* [[Transport optimal par coupe 1D et transfert de couleurs entre images]] (Lucas CHARDONNET)
* [[Génération et résolution de labyrinthes II]] (Romain THEODET)
* [[Rest & Pub-Sub : protocole hybride pour l'IoT]] (Ewan RAKOTOANOSY)
* [[La suite de Conway et la classification périodique des "éléments"]] (Yohann THEPAUT)
* [[Initiation à la démonstration sur ordinateur et certification de logiciel]] (Loïc DORNET)
* [[Dilemme du prisonnier]] (Christophe CARMAGNAC)

= Sujets proposés (2018-2019) =

* Transport optimal par coupe 1D et transfert de couleurs entre images
* Génération et résolution de labyrinthes II
* REST + Pub/Sub : protocole hybride pour l’IoT
* La suite de Conway et la classification périodique des "éléments"
* Initiation à la démonstration sur ordinateur et certification de logiciel
* Algorithmes probabilistes/déterministes pour tester la primalité d'un entier
* Dilemme du prisonnier

== Transport optimal par coupe 1D et transfert de couleurs entre images ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: Le transfert de couleurs de l'image Y vers l'image X consiste à repeindre "au mieux" l'image X avec la palette de couleurs de l'image Y. L'image repeinte X' a alors les mêmes couleurs que l'image Y (mais les pixels ne sont pas répartis pareils). Voir l'exemple de transfert ci-dessous. Il existe plusieurs techniques de transfert de couleurs, mais nous étudierons une technique basée sur le transport optimal. Comme c'est un problème assez difficile dans le cas général, nous verrons une variante dite par coupe 1D, qui simplifiera considérablement le problème de transport.

[[Fichier:Ex-transfert-couleur-OT.png]]

* Objectifs:
*# comprendre ce qu'est une image niveaux couleur, et ce qu'on appelle le transfert de couleurs.
*# comprendre le principe du transport optimal (discret).
*# comprendre et décrire le principe du transport optimal par coupe 1D, et comment se fait le calcul du meilleur transport dans ce cas.
*# Coder un programme de transfert de couleur, qui prend deux images couleurs et réalise le transfert de couleurs.
*# On pourra ensuite réfléchir à quelques améliorations simples (espace couleur YUV, grouper les pixels).
* Liens pour démarrer
** Le vrai "Transport Optimal" est vite très mathématique (ce sont des mesures qui sont transportées), mais on peut l'aborder beaucoup plus simplement dans le cas discret (un nombre fini de valeurs) comme une simple assignation entre deux ensembles.
** [[https://en.wikipedia.org/wiki/Color_mapping Transfert de couleur Wikipedia]]
** [[https://hal.archives-ouvertes.fr/tel-01246096/file/hdr_hal2.pdf Habilitation de N. Papadakis]] (regardez les images plutôt).

== Génération et résolution de labyrinthes II ==

* Tuteur: François Boussion
* Résumé: On veut générer des labyrinthes aussi grands et complexes que possible, avec des murs dans une grille carré voire d'autres domaines. Comment faire pour qu'il y ait toujours un chemin de l'entrée à la sortie ? Comment faire pour qu'il n'y ait qu'un chemin ? Ensuite, comment trouver la sortie quand on est perdu dans le labyrinthe.
* Objectifs:
*# Comprendre comment représenter un labyrinthe avec une structure de données simple
*# Voir le lien avec la théorie des graphes et voir que le problème se résout de la même façon pour des grilles carrées, hexagonales ou autres.
*# Comprendre l'algorithme d'arbre couvrant minimum
*# Comprendre le principe du parcours en profondeur et de la récursivité
* Pour aller plus loin
*# coder la génération d'un labyrinthe et sa visualisation
*# introduire des poids pour varier le labyrinthe
*# comment faire un labyrinthe sur grille hexagonale avec des tableaux.
* Liens pour démarrer
** [[https://fr.wikipedia.org/wiki/Mod%C3%A9lisation_math%C3%A9matique_d%27un_labyrinthe Wikipedia]]
** [[https://en.wikipedia.org/wiki/Maze_generation_algorithm Version anglaise plus complète]]

== REST + Pub/Sub : protocole hybride pour l’IoT ==

* Tuteur: David Télisson
* Résumé: L’avènement de l’Internet des Objets (IoT) depuis une dizaine d’années a fait apparaitre des problématiques propres aux protocoles de communications liées à ces objets. En effet, l’échange de données dans ce contexte nécessite de tenir compte (au moins) des paramètres suivant :
*# Autonomie énergétique souvent limitée
*# Faible puissance des processeurs et taille réduite de la mémoire
*# Disponibilité « aléatoire » de l’accès aux réseaux de communication

De nombreux protocoles cohabitent et la littérature du domaine foisonne d’exemples autour des réseaux dédiées (LORA, Sigfox, etc.) et des protocoles applicatifs (OPC-UA, MQTT, CoaP, XMPP) mais force est de constater que dans la réalité, ces solutions ne répondent pas toujours aux besoins des concepteurs qui leurs préfèrent encore le protocole HTTP. Celui-ci offre l’avantage d’implémenter un protocole applicatif (REST) en même temps qu’un protocole de transport de haut niveau (TCP/IP) permettant de passer les pare-feu. Cependant, la version actuel d’HTTP ne répond pas vraiment aux critères énoncés précédemment.
Depuis quelques années émerge donc l’idée d’enrichir HTTP pour créer un protocole hybride qui mêlerait les avantages de REST avec ceux proposés par les mécanismes de type Publish/Subscribe (MQTT, AMQP, JMS, etc.). En attendant cette éventuelle évolution, peut-on envisager de mettre en place un mécanisme de type Pub/Sub avec le protocole Websocket au-dessus d’HTTP ?

* Objectifs:
*# Etudier et faire une synthèse des deux approches : REST et Pub/Sub
*# Implémentez un PoC (proof of concept) d’une solution hybride qui met en œuvre un mécanisme de Pub/Sub sur Websocket. .
*# Présenter un protocole de test pour valider ou invalider cette solution

* Liens pour démarrer :
** https://nsrc.org/workshops/2018/apricot/iot/presentations/mqttvsrest_v4.pdf
** http://www.tigli.fr/lib/exe/fetch.php?media=cours:tutorial_mqtt_mit_2015_2016.pdf
** https://openclassrooms.com/fr/courses/3449001-utilisez-des-api-rest-dans-vos-projets-web
** http://www.lirmm.fr/~tibermacin/ens/ws/expose.pdf

== La suite de Conway et la classification périodique des "éléments" ==

* Tuteur : Pierre Hyvernat
* La suite de Conway est la suite suivante : 1 ; 11 ; 21 ; 1211 ; 111221 ; ... Chaque terme est obtenu en "lisant" le terme précédent.
** "1" : un "1" -> 11
** "11" : deux "1" -> 21
** "21" : un "2", un "1" -> 1211
** "1211" : un "1", un "2", deux "1" -> 111221
** etc.
Cette suite possède des propriétés étonantes données par le théorème "chimique", le théorème "arithmétique" et le théorème "cosmologique".
* Objectifs :
*# comprendre les énoncés de ces théorèmes, et l'idée de la preuve du premier.
*# programmer la suite de Conway pour retrouver la classification des "atomes"
*# écrire un programme pour calculer expérimentalement une approximation de la constante "lambda" ainsi que des fréquences respectives des différents atomes.
*# écrire un programme pour calculer la suite de Robinson, une variante plus simple de la suite de Conway

* Liens pour commencer
** [[https://fr.wikipedia.org/wiki/Suite_de_Conway suite de Conway]]
** [[https://fr.wikipedia.org/wiki/Suite_de_Robinson suite de Robinson]]

== [[Initiation à la démonstration sur ordinateur et certification de logiciel]] ==

* Tuteur: Tom Hirschowitz
* Résumé: [[https://coq.inria.fr Coq]] est un logiciel de mathématiques sur ordinateur, grâce auquel des programmes élaborés ont pu être certifiés ces dernières années.
* Objectifs:
*# prendre en main le logiciel [[https://coq.inria.fr Coq]] de démonstration sur ordinateur,
*# programmer certaines démonstrations basiques en Coq,
*# suivre le début du cours [[https://www.cis.upenn.edu/~bcpierce/sf Software Foundations]],
* Pour aller plus loin : Software Foundations est un cours assez long et très bien fait, il y aura suffisamment à faire. Eventuellement, selon l'intérêt de l'étudiant, étude des fondements mathématiques de Coq.
* Liens pour démarrer
** [[https://www.cis.upenn.edu/~bcpierce/sf Software Foundations]]
** [[https://coq.inria.fr Coq]]

== Algorithmes probabilistes/déterministes pour tester la primalité d'un entier ==

* Tuteur : Sébastien Tavenas
* Pouvoir tester si un entier est un nombre premier semble être une brique de base si l'on souhaite faire de l'arithmétique sur un ordinateur. Le crible d'Érathostène enseigné dans les petites classes se montre beaucoup trop lent en pratique. L'algorithme probabiliste utilisé le plus rapide est le test de Fermat. Or, si on regarde les algorithmes des librairies "génériques", on peut s'apercevoir que la fonction 'mpz_probab_prime_p' de la librairie 'gmp' sur c++ utilise un test probabiliste de Miller-Rabin, la fonction 'isPrime' de la classe 'Prime' dans java utilise aussi un test de Miller-Rabin mais qui est déterminisé, alors que la fonction 'isprime' de la librairie 'sympy' dans python effectue un test de Miller-Rabin si l'entier est plus petit que 2^64 et un test BPSW fort si l'entier est plus grand. Ainsi, une fonction déjà implémentée de test de primalité peut se tromper ou non, être instantanée ou moins. Que dire alors de l'algorithme polynomial déterministe et toujours correct proposé par AKS?
* Objectifs :
*# Comprendre quelques tests de primalité et comment l'aléatoire est utilisé dans ces algorithmes
*# Comprendre la notion de nombre pseudopremier qui explique, entre autre, quand il vaut mieux utiliser le test de Fermat ou celui de Miller-Rabin
*# Programmer quelques uns des ces tests et les comparer
*# Essayer de dérandomiser ces tests à l'aide de hitting-sets précalculés

* Liens pour commencer
** [[https://en.wikipedia.org/wiki/Primality_test Tests de primalité]]

== Dilemme du prisonnier ==

* Tuteur: Gerald Cavallini
* Résumé: Le dilemme du prisonnier caractérise en théorie des jeux une situation où deux joueurs auraient
intérêt à coopérer, mais où, en l’absence de communication entre les deux joueurs, chacun choisira
de trahir l'autre si le jeu n'est joué qu'une fois.

On peut informatiquement modéliser ce dilemme à l’aide de matrices de gains et conserver la
mémoire des choix de l’adversaire. Ce modèle appliqué à un grand nombre d’individus peut être
utilisé pour comprendre l’émergence de stratégies stables dans l’économie, l’écologie, l’évolution
des espèces ...

On peut visualiser spatialement les interactions entre individus en les représentants par des pixels et
en leurs associant une couleur en fonction de leurs stratégies.

[[Fichier:Dilemme.png]]

* Objectifs
*# Comprendre le dilemme du prisonnier
*# Comprendre la notion de stratégie
*# Penser un modèle spatiale pour « opposer » des individus qui appliquent des stratégies différentes
*# Développer une interface pour visualiser dans le temps l’évolution d’une population d’individus adoptants des stratégies différentes.

* Lien :
*# [https://fr.wikipedia.org/wiki/Dilemme_du_prisonnier Dilemme du prisonnier Wikipedia]
*# [http://cormas.cirad.fr/fr/applica/dps.htm Site spécifique]

= Sujets réalisés (2017-2018) =

* [[VISI201 Analyse syntaxique (Tristan Porteries, 2018)]]
* [[Segmentation d'image par détection de contours et algorithme "ligne de partage des eaux"]] (Nils Ruet, 2018)
* [[Fouille de données textuelles à partir des "Exercices de style" de R. Queneau]] (Rémi Bouvier, 2018)
* [[Transformées en distance, diagramme de Voronoi et applications en geometry processing]] (Robin Wagner, 2018)
* [[Pavages de Penrose]] (Brunelle Cordier-Pierre-Bès, 2018)

= Sujets proposés (2017-2018) =

* Segmentation d'image par détection de contours et algorithme "ligne de partage des eaux"
* Initiation à la démonstration sur ordinateur et certification de logiciel
* Fouille de données textuelles à partir des "Exercices de style" de R. Queneau
* Transformées en distance, diagramme de Voronoi et applications en geometry processing
* Pavages de Penrose

== [[Segmentation d'image par détection de contours et algorithme "ligne de partage des eaux"]] ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: La segmentation d'image vise à identifier les régions d'intérêt dans une image. Typiquement, une région d'intérêt est une zone de l'image plutôt homogène (les pixels ont des valeurs proches) et le contour entre deux régions d'intérêt est tracé là où les valeurs subissent de fortes variations. La méthode de segmentation proposée ici suit ce principe en enchaînant deux calculs: (1) un premier traitement calcule une image "gradient" et fabrique une image dont les valeurs élevées correspondent à des zones de fortes variations, (2) le deuxième algorithme voit cette image comme un relief 3D et identifie ses bassins hydrographiques. Cette identification des lignes de partage des eaux permet de découper l'image en ses zones d'intérêt.
* Objectifs:
*# comprendre ce qu'est une image niveaux de gris ou couleur, ce qu'est le gradient d'une image et ce qu'on appelle segmentation d'image.
*# décrire un algorithme de calcul du gradient d'une image, e.g. le filtre de Sobel, voire les convolutions par dérivées de Gaussienne.
*# décrire le principe de ligne de partage des eaux ("watershed" en anglais), ses différentes définitions équivalentes, et les différents types d'algorithmes pour la calculer.
*# Coder un programme de segmentation d'image, qui prend une image (niveaux de gris) en entrée, calcule son gradient, et extrait les bassins de sa ligne de partage des eaux.
* Liens pour démarrer
** [[https://en.wikipedia.org/wiki/Watershed_(image_processing) Watershed Wikipedia]]
** Luc Vincent and Pierre Soille. Watersheds in digital spaces: an efficient algorithm based on immersion simulations. In IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol. 13, Num. 6 (1991), pages 583–598 [[https://pdfs.semanticscholar.org/a381/9dda9a5f00dbb8cd3413ca7422e37a0d5794.pdf PDF]]

== [[Initiation à la démonstration sur ordinateur et certification de logiciel]] ==

* Tuteur: Tom Hirschowitz
* Résumé: [[https://coq.inria.fr Coq]] est un logiciel de mathématiques sur ordinateur, grâce auquel des programmes élaborés ont pu être certifiés ces dernières années.
* Objectifs:
*# prendre en main le logiciel [[https://coq.inria.fr Coq]] de démonstration sur ordinateur,
*# programmer certaines démonstrations basiques en Coq,
*# suivre le début du cours [[https://www.cis.upenn.edu/~bcpierce/sf Software Foundations]],
* Pour aller plus loin : Software Foundations est un cours assez long et très bien fait, il y aura suffisamment à faire. Eventuellement, selon l'intérêt de l'étudiant, étude des fondements mathématiques de Coq.
* Liens pour démarrer
** [[https://www.cis.upenn.edu/~bcpierce/sf Software Foundations]]
** [[https://coq.inria.fr Coq]]

== [[Fouille de données textuelles à partir des "Exercices de style" de R. Queneau]] ==

* Tuteur: Laurent Vuillon
* Résumé: L'idée de ce projet est de se familiariser avec les techniques de fouille de données textuelles à partir des "Exercices de style" de R. Queneau (https://fr.wikipedia.org/wiki/Exercices_de_style). On cherchera à comprendre la structure du vocabulaire du corpus de textes, à utiliser les techniques de TF/IDF pour extraire les mots significatifs du corpus puis à tester les techniques de LDA (Allocation de Dirichlet latente) pour extraire automatiquement les thématiques du corpus afin de construire des regroupements par thème. On pourra également proposer des visualisations des résultats afin de rendre accessible visuellement l'analyse de données produite sur le corpus de documents.
* Objectifs: Introduction à la fouille de données au travers d'un cas pratique
* Pour aller plus loin
** http://blogperso.univ-rennes1.fr/stephane.tuffery/
** http://www.editionstechnip.com/en/catalogue-detail/1005/data-mining-et-statistique-decisionnelle.html
* Liens pour démarrer
** https://fr.wikipedia.org/wiki/Exploration_de_donn%C3%A9es
** https://fr.wikipedia.org/wiki/TF-IDF
** "Recherche d'information : applications, modèles et algorithmes; Data mining, décisionnel et big data" de Amini et Gaussier aux éditions Eyrolles.

== [[Transformées en distance, diagramme de Voronoi et applications en geometry processing]] ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: Les nuages de points constituent une source de données géométriques importantes (cf LIDAR scanner, 3D scanner) et qui permet de construire des modèles géométriques 3D d'objets réels. La difficulté est de transformer ces nuages de points en des surfaces (souvent des surfaces triangulées, c'est-à-dire des triangles collés entre eux). Un outil essentiel dans ce processus est la transformée en distance, le diagramme de Voronoi (et son dual la triangulation de Delaunay). A partir de ces outils, des algorithmes existent pour reconstruire les surfaces, estimer la géométrie du nuage de point (sa normale par exemple), etc.
* Objectifs:
*# Comprendre ce qu'est une distance, une transformée en distance, et un diagramme de Voronoi. Comprendre ce qu'est la stabilité d'une fonction.
*# Identifier les propriétés des diagrammes de Voronoi, de leur dual la triangulation de Delaunay, et comprendre leurs variantes comme les diagrammes de puissance
*# Identifier le lien avec l'axe médian et les squelettes
*# Décrire les principaux algorithmes de calcul des transformées en distance et du diagramme de Voronoi, pour des nuages de point quelconques ou pour des nuages de points à coordonnées entières.
*# Présenter un algorithme de reconstruction de surface utilisant le diagramme de Voronoi
*# Coder un algorithme de calcul du diagramme de Voronoi et, si le temps le permet, un algorithme de reconstruction de surface.

* Liens pour démarrer
** [[https://en.wikipedia.org/wiki/Voronoi_diagram Diagramme de Voronoi Wikipedia]]
** [[https://en.wikipedia.org/wiki/Distance_transform Transformée en distance Wikipedia]]
** [[https://en.wikipedia.org/wiki/Topological_skeleton Squelette Wikipedia]]
** [[http://dgtal.org/doc/nightly/moduleVolumetric.html Transformées discrètes en distance DGtal]]

== [[Pavages de Penrose]] ==

* Tuteur : Pierre Hyvernat
* Résumé : le "cerf-volant" et la "fléchette" de Penrose sont deux tuiles qui permettent de recouvrir le plan, mais uniquement de manière non-périodique. Autrement dit, les pavages correspondants ne sont pas obtenus en répétant un même motif de manière régulière. A cause de ceci, il n'est pas évident de générer un tel pavage.

[[Fichier:P2.png]]

* Objectifs
*# comprendre les notion de pavage périodique, non périodique et apériodique,
*# comprendre la méthode "inflation / déflation" pour générer des pavages de Penrose des différents types,
*# comprendre le lien entre les 2 (ou 3) types de pavage de Penrose
*# écrire un programme permettant de générer de tels pavages : avec la méthode "inflation / déflation" et avec la méthode "grille de de Bruijn"
*# utiliser ces méthodes pour générer d'autres types de pavages apériodique.

* Liens pour démarrer
** [[https://fr.wikipedia.org/wiki/Pavage_de_Penrose pavage de Penrose (wikipedia]]
** [[https://www.maa.org/sites/default/files/pdf/pubs/focus/Gardner_PenroseTilings1-1977.pdf Penrose Tiling (Marting Gardner, en anglais)]]

== [[Algorithmes d'analyse syntaxique]] ==

* Tuteur : Pierre Hyvernat

* Résumé : le code source d'un programme, d'un fichier de configuration d'un serveur de base de données ou le code d'une page web sont des données ''textuelles'' et ''structurées''. Il est possible de définir exactement quelles données sont correctes, et quelle est leur signification. (Cela est beaucoup plus difficile pour des textes en langue naturelle par exemple.) En ce sens, il est possible de lire, d'interpréter ces données à l'aide d'un programme. On parle ''d'analyseur syntaxique'' ou de ''parseur''. Il existe de nombreux outils pour faire ça automatiquement, mais il est parfois important (et toujours intéressant) de comprendre les mécanismes correspondant. C'est ce que ce stage propose de faire.

* Objectifs :
*# étudier la formalisation du problème à travers la notion de ''langage'' et les premiers étages de la hiérachie de Chomsky (langages réguliers et grammaires hors contexte).
*# comprendre le lien entre les langages et les automates (automates finis / automates à pile)
*# implémenter un parseur "from scratch" et le tester sur des petits exemples simples, "à la main", soit en calculant "à la volée" la sémantique d'un langage, soit en produisant des "arbres de syntaxe abstraits", qui pourront être analysés par la suite,
*# comprendre les restrictions souvent imposées sur les grammaires afin d'améliorer l'efficacité du parseur (''LL*(k)'', ''LR'', etc.)
*# à partir de là, de nombreuses pistes sont ouvertes :
*#* essayer d'écrire un petit outils qui puisse lire une grammaire, et générer un parseur pour cette grammaire,
*#* comparer l'approche "automate" avec l'approche "combinateurs" et "parseur récursifs"
*#* améliorer l'efficacité des parseurs produits
*#* ajouter des fonctionnalités,
*#* ...

* Liens pour démarrer :
** [[https://en.wikipedia.org/wiki/Parsing page wikipedia "parsing"]]
** [[https://en.wikipedia.org/wiki/Recursive_descent_parser page wikipedia "recursive descent parser"]]
** Le livre référence sur le parsing est probablement "Compilers: Principles, Techniques, and Tools" de Aho, Sethi et Ullman (le "dragon book")
** [[https://web.stanford.edu/class/archive/cs/cs143/cs143.1128/ exemples de notes cours de compilation]]

= Sujets réalisés (2016-2017) =

* [[Algorithme de rendu de scène 3D par Z-buffer]]
* [[Traitement d'image]]
* [[Nim et la théorie des jeux impartiaux]]
* [[Calculabilité et modèles de calcul]]
* [[Génération et résolution de labyrinthes]]

= Sujets proposés (2016-2017) =

== [[Algorithme de rendu de scène 3D par Z-buffer]] ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: Le Z-buffer est un algorithme classique de rendu de scène 3D. C'est celui (avec quelques variantes) qui est implémenté dans nos cartes graphiques 3D et qui permet de visualiser des scènes extrêmement complexes en temps réel (typiquement 24 image/s).
* Objectifs:
*# décrire le principe de la projection 3D vers 2D
*# décrire la rastérisation des triangles sur une image en pixel
*# expliquer le principe du Z-buffer qui permet de gérer le fait que certains objets sont cachés par d'autres
*# expliquer comment les couleurs sont calculées par pixel
*# indiquer les qualités et limitations de l'algorithme
* Pour aller plus loin
*# mettre du code démo (WebGL) avec quelques explications sur le pipeline graphique OpenGL
*# expliquer comment on peut utiliser cet algorithme pour calculer des ombres (shadow map)
* Liens pour démarrer
** [[https://fr.wikipedia.org/wiki/Z-buffer Wikipedia]]
** [[https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/overview-rasterization-algorithm Scratch a pixel]]

== [[Traitement d'image]] ==

* Tuteur: Jacques-Olivier Lachaud
* Résumé: Le traitement d'image rassemble tous les algorithmes utilisés pour transformer les images, les améliorer, éliminer certaines perturbations, augmenter ou diminuer le contraste, changer les couleurs vers d'autres couleurs, éliminer le flou ou les yeux rouges, faire du cartooning pour un rendu moins photo-réaliste, etc.
* Objectifs:
*# identifier les grandes familles de traitement: restauration, égalisation, élimination du flou de déplacement, segmentation, etc
*# identifier les grandes familles de techniques: filtrage spatial, filtrage fréquentiel, optimisation, etc
*# comprendre les points communs et différences entre le traitement des images noir et blanc et le traitement des images couleurs.
*# choisir un ou deux algorithmes de traitement et les expliquer en détails
* Pour aller plus loin
*# Coder un algorithme de traitement d'image simple (e.g, un filtrage médian, ou un algo qui transporte les couleurs d'une photo vers une autre photo)

* Liens pour démarrer
** [[https://fr.wikipedia.org/wiki/Traitement_d%27images Wikipedia]]
** [[http://www.ipol.im/ Image Processing on line]] (permet de tester en ligne des algorithmes sur vos images)

== [[Nim et la théorie des jeux impartiaux]] ==

* Tuteur: Pierre Hyvernat

* Étudiant : Luca Chapelle

* Le jeu de Nim (aussi appelé jeu des allumettes) est l'un des premiers jeux ayant été analysé mathématiquement (par Charles Bouton en 1901). Les stratégies gagnantes peuvent être calculées en utilisant le développement en base 2 des nombres, et l'opération d'"addition de Nim" (XOR). La théorie de ce type de jeux (jeux "impartiaux") est assez simple, mais de nombreuses instances de jeux sont encore non résolues.
* Objectifs:
*# comprendre la théorie du jeu de Nim (et la programmer)
*# comprendre le théorème de Sprague Grundy qui montre que tout jeu impartial est équivalent à un jeu de nim
*# regarder quelques autres exemples de tels jeux : jeu de Nim déguisés, ou jeux véritablement différents
*# programmer une version naịve de recherche de stratégie basée sur le théorème de Sprague-Grundy pour quelques jeux

* Liens pour commencer
** [https://fr.wikipedia.org/wiki/Jeux_de_Nim jeu de Nim]
** [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Sprague-Grundy théorème de Sprague Grundy]
** [https://fr.wikipedia.org/wiki/Jeu_de_Grundy jeu de Grundy]

== La suite de Conway et la classification périodique des "éléments" ==

* Tuteur : Pierre Hyvernat
* La suite de Conway est la suite suivante : 1 ; 11 ; 21 ; 1211 ; 111221 ; ... Chaque terme est obtenu en "lisant" le terme précédent.
** "1" : un "1" -> 11
** "11" : deux "1" -> 21
** "21" : un "2", un "1" -> 1211
** "1211" : un "1", un "2", deux "1" -> 111221
** etc.
Cette suite possède des propriétés étonantes données par le théorème "chimique", le théorème "arithmétique" et le théorème "cosmologique".
* Objectifs :
*# comprendre les énoncés de ces théorèmes, et l'idée de la preuve du premier.
*# programmer la suite de Conway pour retrouver la classification des "atomes"
*# écrire un programme pour calculer expérimentalement une approximation de la constante "lambda" ainsi que des fréquences respectives des différents atomes.
*# écrire un programme pour calculer la suite de Robinson, une variante plus simple de la suite de Conway

* Liens pour commencer
** [[https://fr.wikipedia.org/wiki/Suite_de_Conway suite de Conway]]
** [[https://fr.wikipedia.org/wiki/Suite_de_Robinson suite de Robinson]]

== Initiation à la démonstration sur ordinateur et certification de logiciel ==

* Tuteur: Tom Hirschowitz
* Résumé: [[https://coq.inria.fr Coq]] est un logiciel de mathématiques sur ordinateur, grâce auquel des programmes élaborés ont pu être certifiés ces dernières années.
* Objectifs:
*# prendre en main le logiciel [[https://coq.inria.fr Coq]] de démonstration sur ordinateur,
*# programmer certaines démonstrations basiques en Coq,
*# suivre le début du cours [[https://www.cis.upenn.edu/~bcpierce/sf Software Foundations]],
* Pour aller plus loin : Software Foundations est un cours assez long et très bien fait, il y aura suffisamment à faire. Eventuellement, selon l'intérêt de l'étudiant, étude des fondements mathématiques de Coq.
* Liens pour démarrer
** [[https://www.cis.upenn.edu/~bcpierce/sf Software Foundations]]
** [[https://coq.inria.fr Coq]]

== [[Calculabilité et modèles de calcul]] ==

* Tuteur: Rodolphe Lepigre
* Résumé: Une fonction f sur l'ensemble des entiers naturels est dite calculable s'il existe une procedure effective (ou un algorithme) qui permet, étant donné un entier n, de calculer f(n) en temps fini. Il existe divers modèles de calcul qui permettent de représenter toutes les fonctions calculables : machines de Turing, λ-calcul, automates cellulaires, ...
* Objectifs:
*# comprendre la notion de fonction calculable,
*# comparer l'ensemble des fonctions à l'ensemble des fonctions calculables,
*# regarder et comparer quelque modèles de calcul,
*# programmer un modèle de calcul et comprendre les limitations pratiques.

* Liens pour commencer:
** https://fr.wikipedia.org/wiki/Calculabilité
** https://fr.wikipedia.org/wiki/Machine_de_Turing
** https://fr.wikipedia.org/wiki/Lambda-calcul
** https://fr.wikipedia.org/wiki/Jeu_de_la_vie

== [[Génération et résolution de labyrinthes]] ==

* Tuteur: <strike>Jacques-Olivier Lachaud</strike> Xavier Provençal
* Résumé: On veut générer des labyrinthes aussi grands et complexes que possible, avec des murs dans une grille carré voire d'autres domaines. Comment faire pour qu'il y ait toujours un chemin de l'entrée à la sortie ? Comment faire pour qu'il n'y ait qu'un chemin ? Ensuite, comment trouver la sortie quand on est perdu dans le labyrinthe.
* Objectifs:
*# Comprendre comment représenter avec une structure de données un labyrinthe
*# Voir le lien avec la théorie des graphes et voir que le problème se résout de la même façon pour des grilles carrées, hexagonales ou autres.
*# Comprendre l'algorithme d'arbre couvrant minimum
*# Comprendre le principe du parcours en profondeur et de la récursivité
* Pour aller plus loin
*# coder la génération d'un labyrinthe et sa visualisation
* Liens pour démarrer
** [[https://fr.wikipedia.org/wiki/Mod%C3%A9lisation_math%C3%A9matique_d%27un_labyrinthe Wikipedia]]
** [[https://en.wikipedia.org/wiki/Maze_generation_algorithm Version anglaise plus complète]]

== Pavages par polyomino ==

* Tuteur: Xavier Provençal
* Résumé : On s'intéresse aux pavages du plan par des tuiles formées de petits carrés collés les uns aux autres, appelé "polyominos". Étant donné une tuile, peut-on paver le plan ? Si oui, avec quelles opérations (translation et/ou rotations et/ou réflexions) Une fois un pavage réalisé, on observe ses propriétés. Quelles symétries ? Le pavage est-il identique du point de vue de chacune des tuiles ? Si ce n'est pas le cas, en combien de classes peut-on diviser ces tuiles ?
On s'intéressera aussi à des propriétés connexes. Au lieu de paver tout le plan, on peut essayer de paver une région finie donnée. Plus localement, peut-on encercler complètement une tuile avec des copies d'elle-même, sans former de trous ? Si oui, peut-on faire de même avec la proto-tuile formée par la tuile de départ et toutes ses copies ? Si oui, combien de fois peut-on répéter l'opération ?
* Objectifs :
*# Comprendre les différentes classes de pavages (isohédral, k-isohédral, anisohédral).
*# Pour chacun des sept types de pavages "isohédraux", comprendre le lien entre les symétries du pavages et la caractérisation des tuiles qui le réalisent.
*# Pour un pavage k-isohédral, identifier les "classes d'équivalences" et le "domaine fondamental".
* Pour aller plus loin :
*# Coder la génération de tuiles capables de paver le plan en fonction pour une classe de pavages donnée.
*# Étudier et implémenter certains algorithmes pour le pavages d'un domaine fini.
* Liens pour démarrer
** [[https://fr.wikipedia.org/wiki/Polyomino Polyomino]]
** [[https://en.wikipedia.org/wiki/Polyomino Polyomino (en)]]
** [[https://fr.wikipedia.org/wiki/Pavage_par_des_polygones_r%C3%A9guliers Pavages]]

Apprentissage automatique

2020-05-17T15:35:06Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon programme.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour que cet apprentissage ait lieu, il faut un support à améliorer. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:34:36Z

El-huissier : /* Application */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon programme.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour que cet apprentissage ait lieu, il faut un support à améliorer. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 
Le code final se trouve dans la partie source. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]
Le code entier est disponible dans la partie source

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:33:49Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon programme.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour que cet apprentissage ait lieu, il faut un support à améliorer. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]
Le code entier est disponible dans la partie source

== Sources ==
[https://github.com/Kroklethon/VISI201/blob/master/reconnaissance_chiffre.py CODE ENTIER] 
[http://www.http://neuralnetworksanddeeplearning.com/ Neural Networks and Deep Learning] 
[https://pytorch.org/ PyTorch] 
[https://www.miximum.fr/blog/introduction-au-deep-learning-2/ Backpropagation]

Apprentissage automatique

2020-05-17T15:15:54Z

El-huissier : /* Résultats */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon programme.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour que cet apprentissage ait lieu, il faut un support à améliorer. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand. 
[[Fichier:Accur_finale.png]]

Fichier:Accur finale.png

2020-05-17T15:15:36Z

El-huissier :

Apprentissage automatique

2020-05-17T15:13:57Z

El-huissier : /* Application */

L'objectif de ce projet était de se familiariser et de comprendre l'apprentissage automatique, plus communément appelé Deep Learning. Pour ceci, il faut premièrement définir ce qu'est un neurone (en informatique) et donc un réseau de neurones. On parlera ensuite de la façon dont ces systèmes s'adaptent d'eux même, et comment on peut réduire la vitesse d'amélioration pour obtenir un bon programme.

== Deep Learning ==
Le Deep Learning est le procédé par lequel un programme va apprendre lui même tout au long de son fonctionnement, mais plus particulièrement durant une période appelé le "training", l'entraînement en français. Durant cette période, on donne au programme des échantillons d'entraînement, qui contiennent la réponse que devrait donner le programme pour que celui-ci s'adapte en fonction de ses erreurs. À la fin, le programme possède un pourcentage de réussite qui définit sa fiabilité par la suite.

== Neurones ==
Pour que cet apprentissage ait lieu, il faut un support à améliorer. Ce support ne sont d'autres que des neurones:

=== Perceptrons ===
[[Fichier:Perceptron.png]] 
Ce type de neurone créé dans les années 50 a un fonctionnement simple. En effet, le neurone prend plusieurs entrées binaire (0 ou 1) pour donner une sortie binaire.
 [[Fichier:Percerptron_eq.png]] 
Comme le montre les inéquations ci dessus, chaque entrée possède un poids qui donne son importance. Si la somme du produit de chaque entrée et de son poids est supérieur à une valeur seuil alors le neurone donne un 1 sinon il donne un 0.
Nous pouvons aussi interpréter ces inéquations, en faisant entrer en jeu le biais noté b qui va être en quelque sorte la difficulté pour que le perceptron retourne un 1.
 
[[Fichier:Perceptron_eq_biais.png]]
 
Pour améliorer le jugement d'un perceptron, il faut donc faire varier le poids et le biais de chaque entrée afin de retourner le bit qu'il doit donner.

=== Les neurones sigmoïdes ===
Un majeur problème du perceptron est qu'un faible changement des poids et des biais peu résulter en un changement total du résultat, nous éloignant fortement du résultat attendu. Nous voulons qu'un petit changement nous rapproche encore plus du résultat parfait quoi qu'il arrive pour éviter les erreurs et ne nous mène pas vers un résultat complètement différent. 
Le neurone sigmoïde est fait pour éviter ses problème, en effet comme le perceptron il possède un poids et un biais par entrée cependant sa sortie n'est pas 0 ou 1 mais σ(w⋅x+b) où
 
[[Fichier:Sigmoid_function.png]]
 
Si z est positif et très grand alors σ(z) est environ égal à 1, si z est négatif et très petit alors σ(z) est environ égale à 0. Dans les extrêmes le neurone sigmoïde se comporte tout comme un perceptron. La différence est visible quand w⋅x+b est un nombre de taille raisonnable, la sortie n'étant plus 0 ou 1 mais un flottant compris entre 0 et 1. On peut voir cela sur la courbe de la fonction :
 
[[Fichier:Coubre_sigmoid.png]]
 
Le neurone sigmoïde est donc bien plus précis que le perceptron évitant les dérivations du résultat. 

=== Réseaux de neurones ===
L'objectif de ces neurones n'est pas de rester seul mais bien de former un réseaux les sorties de plusieurs neurones devenant les entrées d'un neurone.
 
[[Fichier:Reseau.png]]
 
Ces réseaux sont constitués de différentes couches: 
-la couche d'entrées 
-les couches cachées 
-la couche de sorties 
Comme leur nom l'indique, la couche d'entrée contient les entrées données au programme qui vont ensuite être envoyées aux différents neurones de la couche suivante, cette entrée peut être les bits de l'objet à traiter, un par neurone. La couche de sortie contient tous les neurones qui vont donner le résultat du réseau, il peut très bien en avoir un ou plusieurs. 
Par exemple: 
[[Fichier:Reseau_sortie.png]] 
Ou encore: 
[[Fichier:Reseau_sorties.png]] 

== Descente de gradient ==
Afin de trouver les bons poids et biais pour qu'un neurone fonctionne sans problème, il faut savoir de combien les modifier. On appelle ce procédé la descente de gradient. On prend une fonction que l'on appelle fonction de coût dont les variables sont le poids et le biais, cette fonction représente la distance entre le résultat obtenu et le résultat que nous aurions du obtenir. l'objectif est de minimiser la fonction en trouvant les poids et biais correspondant.
 
[[Fichier:graph_cost.png]]
 
On comprend grâce à cet exemple de graphique de fonction de coût qu'en trouvant les valeurs de poids et biais (ici matérialisés par v1,v2,... en fonction du nombre de dimension) adéquats, on obtient le minimum de la fonction et donc on en conclut que les poids et biais sont les bons. 
D'où le terme de descente de gradient, on cherche à descendre la pente de la fonction pour trouver les bonnes valeurs.
 
[[Fichier:Grad_form.png]]
 
Cela nous donne cette équation nous montre bien, qu'un changement dans les poids et les biais mène à un changement de la valeur de la fonction de coût.
Cette forme donne donc naissance à une autre forme généralisée à toutes les dimensions:
 
[[Fichier:form_gen_grad1.png]]
où
[[Fichier:form_gen_grad2.png]]
et
[[Fichier:form_gen_grad3.png]]
 
Dans l'équation Δv, on note la présence de η qui est le taux d'apprentissage, il permet de choisir à quel point on veut évoluer vite, cependant si la taille est trop grande ou trop petite cela peut nuire à la rapidité d'apprentissage.

=== Backpropagation ===
Cependant pour que la fonction de coût ait un impact sur tout le réseau, il faut pouvoir le parcourir à nouveau pour modifier les valeurs comme il se doit en fonction de l'erreur car la fonction de coût fonctionne avec le résultat et ne peut donc être obtenue avant. 
Pour cela on utilise la backpropagation, qui comme son nom l'indique elle consiste à partir du résultat, et donc de l'erreur, pour trouver les erreurs sur chaque poids ou biais grâce aux couches précédentes. 
En propageant vers l'arrière, on peut bien voir quel poids ont causé la plus grande divergence sur le neurone suivant permettant de les mettre à jour. Par la méthode de la descente de gradient on obtient alors des poids plus près de ceux voulus. On répète ensuite cette algorithme pour chaque échantillon d'entraînement pour obtenir un réseau correct.

== Application ==
Nous allons maintenant créer un réseau que l'on va entraîner à reconnaître les écritures de chiffre manuscrite. 
Pour cela nous allons utiliser plusieurs librairies dont la plus importante : PyTorch, faite pour le deep learning et qui possède un tutoriel très pratique pour se familiariser, elle facilitera l'implémentation des réseaux, fonction de coût et la backpropagation. 
On utilise ici la base de données MNIST contenant 60000 échantillons d'entraînement et 10000 de test. 

=== Préliminaires ===
Il faut premièrement importer tout ce dont nous aurons besoin:
 
[[Fichier:import.png]]
 
 
Ensuite, on importe les données pour l'entraînement et les tests. On définit aussi le nombre de canaux pour les couleurs en transformant les images en tensor (type de matrice utilisée ici) et en les normalisant.
 
On définit les classes possibles, nos résultats.
 
[[Fichier:Creation_set.png]]
 
=== Réseau ===
Nous allons maintenant créer le réseau: 

[[Fichier:class.png]]
 
Pour ceci on dé[[Fichier:Exemple.jpg]]finit de multiple fonction, qui vont définir le réseau. On définit le nombre de canal de couleurs, ici 1, la définition de l'image et le réseau et ses dimensions avec <code> nn.Linear </code> avec lequel on définit le nombre de valeurs d'entrée et de sortie. Cette fonction va appliquer la transformation linéaire y = x*W^T + b avec x l'entrée et y la sortie. 
On définit ensuite la fonction forward qui va permettre d'évoluer dans le réseau.
 
=== Entraînement ===
On doit maintenant définir la phase d'entraînement: 
[[Fichier:training.png]]
 
Nous avons premièrement besoin de définir la fonction de coût (ici loss) et la méthode de descente de gradient (ici SGD = Stochastic Gradient Descent). 
Nous allons faire 2 époque d'entraînement, ce qui est largement suffisant dans notre cas. 
Par la suite on prend des échantillons et leur classe et on les fait passer dans le réseau. Ensuite on calcule l'erreur, la renvoie dans le réseau à l'aide de <code>.backward()</code> et on actualise les poids et biais à l'aide de <code>optimizer.step()</code> 
Pour voir l'avancement du processus on ajoute un affichage nous montrant l'époque, le nombre d'échantillons déjà utilisés et l'erreur moyenne des 2000 derniers échantillons. 
Pour finir cette phase d'entraînement, on sauvegarde l'état actuel du réseau. 

=== Test ===
Nous devons maintenant tester la fiabilité du réseau, pour cela on charge des images aléatoires, on les passe dans le réseau et on compare les résultats. 
[[Fichier:Test_res.png]]
 

=== Additionnel ===
Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction <code> imshow </code>. Celle-ci transforme les images pour être affichées grâce à matplotlib: 
[[Fichier:Imshow.png]] 

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre. 
[[Fichier:accuracy.png]] 
Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut <code> .no_grad() </code> le réseau s'exécute sans calculer les gradients, les erreurs ou encore la backprop, rendant le processus plus rapide car nous voulons juste les résultats. 

=== Résultats ===
J'ai dis précédemment que seulement 2 époques de test allaient nous suffire, en effet si on regarde les résultats obtenus on peut voir que l'on a une précision de 98% ce qui est déjà très correct pour une utilisation comme la notre. Dans le milieu professionnel comme la lecture de chèque de banque 2% d'erreur est déjà bien trop grand.

Fichier:Accuracy.png

2020-05-17T15:07:19Z

El-huissier :

Fichier:Imshow.png

2020-05-17T15:03:35Z

El-huissier :

Fichier:Test res.png

2020-05-17T14:55:48Z

El-huissier :

Fichier:Training.png

2020-05-17T14:40:10Z

El-huissier :

Fichier:Class.png

2020-05-17T14:30:30Z

El-huissier :

Fichier:Creation set.png

2020-05-17T14:18:49Z

El-huissier :

Transformée Burrows Wheeler

2020-05-17T14:15:27Z

El-huissier :

La transformée de Burrows-Wheeler (aussi appelé BWT) est la seconde étape, mais pas des moindres, de l'algorithme de compression [https://en.wikipedia.org/wiki/Bzip2 bzip2]. C'est d'ailleurs l'un des deux principaux rouages de l'algorithme d'après son auteur :

<blockquote>
bzip2 compresses files using the Burrows-Wheeler block sorting text compression algorithm, and Huffman coding.
- Julian Seward
</blockquote>

Vous pouvez essayer cette transformée [http://sb.bde-maite.fr/leonards ici] !

== Utilisation ==
Cette transformée est utilisée pour faire apparaître des motifs redondants dans une séquence de lettres ou d'octets, ce qui aide à la compression avec [https://fr.wikipedia.org/wiki/Codage_de_Huffman l'encoding d'Huffman].

Elle est aussi utilisée dans le domaine de la génétique, pour chercher une sous-chaîne (une séquence) dans un génome humain de plusieurs gigaoctets.

== Principe de fonctionnement ==
=== La transformée ===
La transformé de Burrows-Wheeler se construit à partir d'une matrice de permutations des lettres du mot (ou d'une séquence d'octet de façon générale).

Prenons le mot ''ABRACADABRA''.
Voici les étapes à suivre :

1. On créer la matrice des rotations

Il y a autant de rotations que de lettres/octets

A B R A C A D A B R A
B R A C A D A B R A A
R A C A D A B R A A B
A C A D A B R A A B R
C A D A B R A A B R A
A D A B R A A B R A C
D A B R A A B R A C A
A B R A A B R A C A D
B R A A B R A C A D A
R A A B R A C A D A B
A A B R A C A D A B R

2. On trie les lignes suivant un ordre choisi, qu'il faudra respecter pour l'inverse de la transformée. Ici, je choisis l'ordre alphabétique

A A B R A C A D A B R
A B R A A B R A C A D
A B R A C A D A B R A
A C A D A B R A A B R
A D A B R A A B R A C
B R A A B R A C A D A
B R A C A D A B R A A
C A D A B R A A B R A
D A B R A A B R A C A
R A A B R A C A D A B
R A C A D A B R A A B

3. On trouve la ligne contenant le mot initial, et on retiens sont indice I

A A B R A C A D A B R
A B R A A B R A C A D
'''A B R A C A D A B R A I=3'''
A C A D A B R A A B R
A D A B R A A B R A C
B R A A B R A C A D A
B R A C A D A B R A A
C A D A B R A A B R A
D A B R A A B R A C A
R A A B R A C A D A B
R A C A D A B R A A B

4. Pour finir cette transformée, nous devons avoir l'indice du mot initial et la dernière colonne de la matrice :

A A B R A C A D A B '''R'''
A B R A A B R A C A '''D'''
A B R A C A D A B R '''A''' I=3
A C A D A B R A A B '''R'''
A D A B R A A B R A '''C'''
B R A A B R A C A D '''A'''
B R A C A D A B R A '''A'''
C A D A B R A A B R '''A'''
D A B R A A B R A C '''A'''
R A A B R A C A D A '''B'''
R A C A D A B R A A '''B'''

Le résultat est donc ''3RDARCAAAABB''. On voit que dans cet exemple, quatre ''A'' se suivent ainsi que deux ''B''. Il est facile d'imaginer que sur des séquences beaucoup plus grande, il y aura suffisamment de motifs redondants pour que la compression soit bonne.

=== L'inverse de la transformée ===
Pour reconstruire la séquence d'origine, il faut répéter deux étapes, jusqu'à avoir une matrice carrée :
# On insert la séquence en première colonne
# On tri les lignes par ordre alphabétique
Une fois que nous avons la matrice carré reconstruite, on prend la ligne correspondant à l'indice.

Partons de ''3BNENAA''. L'indice est de 3 et la séquence est ''BNENAA''.

{| class="wikitable"
|-
| Insertion
| Tri
| Insertion
| Tri
| Insertion
| Tri
| Insertion
| Tri
| Insertion
| Tri
| Insertion
| Tri
|-
|
B
N
E
N
A
A
|
A
A
B
E
N
N
|
BA
NA
EB
NE
AN
AN
|
AN
AN
BA
EB
NA
NE
|
BAN
NAN
EBA
NEB
ANA
ANE
|
ANA
ANE
BAN
EBA
NAN
NEB
|
BANA
NANE
EBAN
NEBA
ANAN
ANEB
|
ANAN
ANEB
BANA
EBAN
NANE
NEBA
|
BANAN
NANEB
EBANA
NEBAN
ANANE
ANEBA
|
ANANE
ANEBA
BANAN
EBANA
NANEB
NEBAN
|
BANANE
NANEBA
EBANAN
NEBANA
ANANEB
ANEBAN
|
ANANEB 1
ANEBAN 2
'''BANANE 3'''
EBANAN 4
NANEBA 5
NEBANA 6
|}

Le mot d'origine est donc ''BANANE''.

== Algorithmes ==
À partir du [https://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-124.pdf document de référence], on peut établir plusieurs versions d'implémentations de la transformée de Burrows-Wheeler. Une première "naïve", en appliquant la transformée sans se poser de question. La seconde en se basant sur la partie 4 ''An efficient implémentation'' de l'article officiel.
=== Implémentation naïve ===
==== Algorithmes Python ====

Application :
<pre>
def BTW(word: str) -> Tuple[int, str]:
"""Applique la transformée de Burrows-Wheeler sur `word`"""

# On construit la matrice de rotation en utilisant les listes en compréhension
matrice = [word[i:] + word[:i] for i in range(len(word))]

# On trie (ici, en suivant l'ordre de la table ASCII)
matrice = sorted(matrice)

# On récupère l'indice de la chaine de départ
index = matrice.index(word)

# On renvoie l'indice et la dernière colonne de la matrice
return index, "".join([row[-1] for row in matrice])
</pre>

Application inverse :
<pre>
def invert_BTW(index: int, transformed: str) -> str:
"""Applique l'inverse de la transformée de Burrows-Wheeler en fonction de `index` et `transformed`"""

# On initialise la matrice avec 'nombre de lignes = len(transformed)'
matrice = [ [] for _ in range(len(transformed))]

# Pour chaque caractère (ou colonne)
for _ in range(len(matrice)):

# On insère le mot `transformed` dans la première colonne
for i,row in enumerate(matrice):
row.insert(0, word[i])

# Et on trie les lignes avec la même fonction que précédemment
matrice = sorted(matrice, key=lambda row: "".join(row))

# On renvoie la ligne de la matrice qui nous intéresse, grâce à l'indice de départ
return "".join(matrice[index])
</pre>

==== Limitations ====
Le problème de cet algorithme, c'est qu'à chaque fois nous construisons une matrice de taille <math>N\times N</math>, avec <math>N=</math> taille des données passées à la transformée (e.g. : ABRACADABRA -> Matrice 11,11). Cela n'est pas un problème pour des mots, mais pour des fichiers de plusieurs gigaoctets cela prendrait trop de place mémoire en plus d'être complètement inefficace, dû au grand nombre d'itérations sur la matrice.

=== Implémentation avancée ===
Pour palier le problème de la mémoire, on stocke le mot/fichier dans une variable (dans la réalité, on traitera des fichiers par block, et non pas directement tout le fichier).
Chaque "ligne" de la matrice ne peut en faite contenir que deux informations : une référence à la chaîne de caractère et l'indice de position de la première lettre de la rotation.

Puisque nous voulons trier ces lignes, nous devons pouvoir les comparer (inférieur, supérieur, égale...).

On peut donc créer une classe ''Rotation'' qui réponde à ces critères :

<pre>
class Rotation:
"""
Provide convenient operations on rotated iterables.
`Rotation(s, i)` represent something like `s[i:]`
"""

def __init__(self, string, index):
"""string : methode getitem et lt
string : iterable object passed as reference, implementing standard operators (>,<, ==...)
index : index of first value
"""

self.string = string
self.index = index

def __str__(self):
return str(self.string[self.index:] + self.string[:self.index])

def __repr__(self):
return 'Rot(' + str(self.string[self.index:] + self.string[:self.index]) + ')'

def __getitem__(self, index):
return self.string[(self.index + index)%len(self.string)]

def __len__(self):
return len(self.string) - self.index

def __eq__(self, other):
return self.string == other.string and self.index == other.index

def __lt__(self, other):
""" Lower Than `<` operator
usage : Rotation(s, index2) < Rotation (s, index2)
other : Roration
"""
for i in range(min(len(self), len(other))):
if self[i] < other[i]:
return True
elif self[i] > other[i]:
return False
return len(self) < len(other)

def __le__(self, other):
""" Lower Than `<=` operator
usage : Rotation(s, index2) <= Rotation (s, index2)
other : Roration
"""
if self[0] <= other[0]:
return True
else:
return False

def __gt__(self, other):
""" Lower Than `>` operator
usage : Rotation(s, index2) > Rotation (s, index2)
other : Roration
"""
for i in range(min(len(self), len(other))):
if self[i] > other[i]:
return True
elif self[i] < other[i]:
return False
return False

def __ge__(self, other):
""" Lower Than `>=` operator
usage : Rotation(s, index2) >= Rotation (s, index2)
other : Roration
"""
if self[0] >= other[0]:
return True
else:
return False
</pre>

Avec cette classe, l'implémentation est plutôt simple :
<pre>
def lastCol(rotation_table):
"""Renvoie la dernière colonne d'une matrice sous la forme List<List>"""

return [rotation[-1] for rotation in rotation_table]

def BTW(iterable):
"""Effectue la transformée de Burrows-Wheeler sur un itérable avec la classe Rotation"""

# On crée une liste des rotations
rotation_table = list(map(lambda i: Rotation(iterable, i), range(len(iterable))))

# On la trie
rotation_table = sorted(rotation_table)

index = None

# On cherche l'indice de la chaine de départ
for i, rotation in enumerate(rotation_table):

if rotation.index == 0:
index = i
break

return index, lastCol(rotation_table)
</pre>

Seulement pour l'inverse de la transformée, la classe ''Rotation'' n'est pas d'une grande utilité. Il faut suivre la partie qui traite les optimisations de l'algorithme dans le document officiel.

<pre>
def invert_BTW(index, lastCol):
""" Effectue l'inverse de la transformée de Burrows-Wheeler.

Notation du document offciel :
lastCol = L
len(lastCol) = N
index = I
precedingChars = C, même taille que l'alphabet
P = P, même taille que la colonne
"""

# On cherche à construire T, une liste qui à un numéro de ligne de la matrice M associe une ligne de la matrice M' (M' étant une matrice dont chaque ligne a été décalée de 1)

P = [] # i -> Nombre d'instances du caracère lastCol[i] dans le préfix lastCol[:i] (L[0,...,i-1])
freq = {}

for i, char in enumerate(lastCol):
freqChar = freq.get(char, 0)
P.append(freqChar)
freq[char] = freqChar+1

precedingChars = {}
tmp = 0
for c in sorted(freq.keys()):
precedingChars[c] = tmp
tmp += freq[c]

del freq

T = [] # La liste que nous voulions
for i, char in enumerate(lastCol):
T.append(P[i] + precedingChars[char])

del precedingChars, P

# Explication de la notation du document officiel :
# T^2 = T[T[I]
# T^3 = T[T^2[I] = T[T[T[I]

word = []
tmp = index # Représente le résultat de T^x
for i in range(len(lastCol)):
word.append(lastCol[tmp])
tmp = T[tmp]

word.reverse() # On remet le mot à l'endroit
word = "".join(word)

return word
</pre>

L'avantage de cet algorithme, c'est qu'il utilise en mémoire moins de ressources qu'une matrice de rotations. Il utilise un dictionnaire de la taille de "l'alphabet" de la séquence (un texte français -> 26 lettres *2 (majuscule et minuscule) + les caractères spéciaux) et le texte en question.

== Sources ==
* [https://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-124.pdf A block sorting lossless data compression algorithm]
* [https://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform Wikipedia EN]
* [http://blog.thegrandlocus.com/2016/07/a-tutorial-on-burrows-wheeler-indexing-methods A tutorial on Burrows-Wheeler indexing methods]

Fichier:Import.png

2020-05-17T14:02:40Z

El-huissier :