Apprentissage automatique

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

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.

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.

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ù

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 :

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.

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:

Ou encore:

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.

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.

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:
où et
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:


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.

Réseau

Nous allons maintenant créer le réseau:

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 nn.Linear 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:

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 .backward() et on actualise les poids et biais à l'aide de optimizer.step()
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.

Additionnel

Comme vu dans le paragraphe précédent, on affiche l'image à l'aide de la fonction imshow . Celle-ci transforme les images pour être affichées grâce à matplotlib:

Nous avons aussi deux fonctions qui affichent les pourcentages de réussite globale sur les 10000 échantillons de test et de chaque chiffre.

Ces deux fonctions testent sur 10000 échantillons, cependant avec l'attribut .no_grad() 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.

Sources

CODE ENTIER
Neural Networks and Deep Learning
PyTorch
Backpropagation