Découvrir et comprendre l’Intelligence Artificielle en 4 étapes

Qu’est-ce que l’Intelligence artificielle et un DataSet? 

L’intelligence artificielle (IA) est un ensemble d’algorithmes ayant des capacités d’analyse et de prise de décision à partir d’un ensemble de données, appelé DataSet. L’IA a l’intelligence de s’adapter à plusieurs situations et d'établir des prédictions à partir des données transmises. 

L’intelligence artificielle associe les logiciels à des composants physiques (ou « hardware ») qui peuvent être des capteurs, des interfaces pour l’utilisateur…

Construire un Dataset pour créer notre IA 

Dataset, ou encore un ensemble de données, est un ensemble de valeurs "organisées" ou "contextualisées", où chaque valeur est associée à une variable et à une observation.

Pour obtenir des données permettant de construire notre IA selon nos objectifs, nous pouvons nous référer sur des bases de Dataset d’IA ou d’API déjà existantes. Des solutions Open Source existent et nous pouvons les compiler afin d’obtenir toutes les données nécessaires.

COMMENT CRÉER NOTRE DATASET ? 

Il existe 3 solutions pour construire notre DataSet permettant ainsi à l’IA de s’entraîner : 

• Solution B Des DataSet existent en Open source 
• Solution C Utiliser des données issues de notre entreprise 
• Solution A Utilisation de données résultantes d’un résultat d’IA 

Ces trois moyens permettent de créer un dataset avec le plus de données possibles, permettant ainsi un entraînement complet de notre IA. Car plus une IA possède de la donnée, plus elle répond intelligemment à la demande. 

L'ensemble des données doit, dans la plupart des cas, comporter des données étiquetées. Les données qui ont la même étiquette doivent être stockées dans des classes qui portent le nom de l'étiquette.

Par exemple, l'image d'un chien sera étiquetée dog1 et la classe sera nommée dog.

De plus, le dataset doit être séparé en 2 voir 3 catégories :

• Entraînement : 80 % des données seront utilisées pour l’entraînement de l’IA
• Validation : 20 % des données seront utilisées afin de valider l’IA entraînée. → on va entraîner un modèle d’IA 
• Test : (10%) des données seront utilisées afin de tester les performances de l’IA entraînée.

On sépare les données en mettant un maximum de données dans la partie entraînement car c’est dans cette partie que l’IA a le plus besoin de données. Cependant, 20% des données doivent être utilisées pour évaluer le modèle d’IA. Car si on stocke toutes les données dans l’entraînement, l’IA ne ferait qu’un travail de mémoire et ne serait pas capable de généraliser son modèle à de nouvelles données. C’est pourquoi généralement, on prend 80% des données pour entraîner l’IA.

Construire votre IA 

Comment fonctionne le Machine Learning ? 

Une fois le dataset créé, on peut passer à la création de l’IA. Comment choisir sur quel modèle partir, le Deep Learning ou le Machine Learning ?

Le Machine learning utilise des modèles en mathématiques, il développe un modèle en se servant d’un algorithme d’optimisation pour minimiser les erreurs entre le modèle et nos données. Le Deep Learning est un sous ensemble du machine learning et nécessite beaucoup plus de données. 

Par exemple, si la dataset possède plus de 50 000 données (ou 100 000 dépendant des usages), on peut utiliser le deep learning. En effet, le Deep Learning se définit comme un apprentissage en profondeur, donc il va utiliser plus de paramètres et plus d’exemples afin de réguler les paramètres. 

Le résultat sera ainsi plus précis, puisque plus de données ont été utilisées. 

En fonction du modèle choisi, on sélectionne les paramètres nécessaires pour entraîner notre IA. Ces paramètres changent d’un modèle à un autre.

Utilisation du Deep Learning pour construire votre IA 

Des modèles de Deep Learning sont d’ores et déjà disponibles en Open Source. Vous pouvez sélectionner un modèle, proche des fonctionnalités que vous souhaitez créer. Par exemple, nous pouvons utiliser un modèle reconnaissant les classes qu’on associe à notre Data Set.

Exemples de modèles de deep learning :

• GoogleNet : reconnaît 1000 classes d’images différentes comme les avions, les voitures, certains animaux, fruits, légumes…
• MobileNet : reconnaît 1000 classes d’images différentes.
• ResNet : reconnaît 1000 classes d’images différentes.
• XLMR_BASE_ENCODER : prédit la sentence suivante à l’aide des mots précédents : https://huggingface.co/docs/transformers/v4.18.0/en/model_doc/bert#overview
• Conformer : permet de détecter la langue utilisée dans un audio : https://arxiv.org/abs/2005.08100

Exemples de modèles disponibles sur Pytorch : 

• Liste de modèle de reconnaissance d’image : https://pytorch.org/vision/stable/models.html
• Liste de modèle portant sur l’audio : https://pytorch.org/audio/stable/models.html
• Liste de modèle de portant sur le text: https://pytorch.org/text/stable/models.html

Adapter le modèle à notre besoin

Tirer profit d’un modèle pour l’adapter à notre besoin

Le Deep Learning utilise la fonction mathématique que l’on peut qualifier de Neurone, qui permet d’adapter le modèle à notre besoin. Capitaliser sur un modèle existant permet de gagner en productivité, toutefois, il est nécessaire de l’adapter à notre besoin. Par exemple, vous pouvez utiliser Google Net et adapter ses paramètres pour former un réseau de neurones.

Une fois la sélection du modèle faite et le rajout d’une couche de neurone effectué, on doit choisir une fonction de perte. Cette fonction permet de valider la direction choisie et de minimiser les erreurs du modèle. 

Exemple de fonction de perte : Cross entropy Loss

Optimiseur

Ensuite, l’optimiseur va utiliser la fonction de perte pour réduire les erreurs et modifier le poids des paramètres afin de réduire l’écart entre les points et la courbe (cf le schéma au dessus). Pour assurer le fonctionnement de l’optimiseur, 3 hyper-paramètres sont nécessaires : 

• Le batch size : le nombre de données traitées par le réseau de neurones avant que les paramètres de celui-ci ne soient changés.
• Number of epochs (nombre d’itération/ de répétition) : le nombre de fois que la dataset sera itéré
• Learning rate (vitesse d’apprentissage) : à quel point les paramètres sont changés à chaque batch/epochs. Un learning rate faible indique un changement faible des paramètres donc plus prédictible.

Exemple d’optimiseurs : Adam, Adagrad, SGD (Stochastic Gradient Descent)

L’entraînement de l’IA comporte deux étapes que l’on va répéter un nombre de fois égale au nombre d’epochs. Elle va d’abord travailler sur les données dites d'entraînement (train) afin d’affiner le modèle et va ensuite vérifier l’efficacité de son modèle sur des images qu’elle n’a pas reçu durant son entraînement.

Évaluer l’IA pour valider l’entraînement 

Une fois l’entraînement terminé, on obtient un modèle d’IA entraîné. Afin de vérifier que le modèle répond à nos attentes, on va l’évaluer sur trois critères :

• Courbes de précisions et de pertes au cours de la phase d’entraînement de l’IA
• Matrice de confusion de l’IA
• Précision finale obtenus

Courbe de précision :

Les courbes de précisions et de pertes de l’IA vont pouvoir nous renseigner sur 3 points :

• Est-ce que l’IA est sous-entrainée
• Est-ce qu’elle est sur entraînée
• Est-ce qu’on aurait pu ou dû arrêter son entraînement plus tôt

L’IA est considérée comme sous-entrainée si on obtient des courbes de précisions qui sont encore en augmentation à la fin de l’entraînement ou que les courbes de la fonction de perte sont toujours en diminution. Cela veut dire que l’IA n’a pas forcément atteint le maximum de précision que ce modèle peut avoir.

Exemple de modèle d’IA sous-entrainée :

Ici, on observe que les courbes d’accuracy durant la phase de training et de test se suivent et sont toujours en augmentation ainsi que les courbes de pertes sont en diminutions et se suivent, ce qui indique qu’on aurait pu augmenter le nombre d’epochs afin d’obtenir une IA avec une meilleure précision. 

Il est aussi possible d’augmenter le learning rate en gardant le même nombre d’epoch. Cependant, ici on a peu d’epoch, on peut donc se permettre plus facilement d’augmenter le nombre d’epoch plutôt que de modifier le learning rate.

À l’aide de la courbe de précision et de perte, on peut aussi déterminer si on est en présence d’overfitting (surentraînement). Le surentraînement est le fait d’avoir une IA qui est très bonne pour faire son travail sur les données sur lesquelles elle s’entraîne mais qui obtient de moins bons résultats sur de nouvelles données qui ne sont pas présentes dans le dataset initial.

Exemple d’overfitting :

La dernière information que l’on peut tirer de ces courbes sont la modification du nombre d’epoch. En effet, si il y a de l’overfitting, on doit arrêter l’entraînement avant d’avoir de l’overfitting donc réduire le nombre d’epoch ou alors modifier le learning rate mais beaucoup plus difficile à contrôler. Si on observe qu’il n’y a plus ou très peu d’évolution, on peut aussi arrêter l’entraînement.

Matrice de confusion :

La matrice de confusion permet de vérifier que le modèle détecte bien toutes les classes de notre dataset. En effet, dans certains cas, le modèle peut, à la fin de son entraînement donner une bonne précision mais ne pas reconnaître toutes les classes avec cette précision. Cela arrive souvent avec un dataset déséquilibré, ie un dataset dont les classes ne contiennent pas le même nombre de données à + ou - 10% près. Par exemple, un dataset avec 1000 images de chiens et 100 images de chat va avoir tendance à toujours donner chien comme réponse car il a 90% d’avoir juste. Il ne peut donc pas détecter ce qui se trouve sur les images. La matrice de confusion va permettre de voir que la classe chat n’est pas détectée et nous permettre de corriger le problème, soit en rajoutant des données dans la classe qui est mal détectée, soit en prenant une fonction de perte qui punit plus sévèrement les erreurs.

Exemple de matrice de confusion :

Ici, on observe que les classes D et E sont généralement mal prédit, la classe D a une précision de 56% et la classe E de 66% alors que les autres classes ont une précision de presque 99%

On peut donc en conclure qu’il faut rajouter des données dans les classes D et E afin d’augmenter la précision sur ces classes. (On observe aussi qu’il devait y avoir de base moins de données dans ces classes, ce qui peut expliquer que l’on obtient cette matrice de confusion)

Une fois que l’on a vérifié les courbes de précisions et de pertes ainsi que la matrice de confusion, on peut s'intéresser à la précision de notre IA. Généralement, avant l’entraînement d’une IA, on définit un niveau de précision souhaité en accord avec les fonctionnalités de l’IA. Une IA utilisée dans une voiture autonome doit avoir une précision proche de 100%, même 99,99% serait trop dangereux pour les usagers de la route.

Si la précision souhaitée n’est pas atteinte, il faut soit modifier le learning rate, le nombre d’epoch ou le batch size, sinon on peut aussi changer la fonction de perte et l’optimiseur et enfin on peut changer de modèle de base d’IA.