Ce qu'est l'apprentissage automatique

Ce que vous saurez faire

Comprenez ce qu’est l’apprentissage automatique avant de créer un modèle. C’est un programme qui apprend une règle à partir d’exemples, plutôt que de suivre une règle écrite par une personne. Vous pourrez ensuite voir quand il aide et quand une règle simple écrite est le meilleur choix.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter compare une règle de détection de pourriels écrite par une personne à un modèle entraîné sur 12 messages. Il examine ensuite pour la première fois l’historique des billets de Larkfield. Ses cellules de configuration installent pandas et scikit-learn et téléchargent les données d’exercice. Vous n’avez donc rien à configurer localement. Environ 20 minutes.

Ouvrir dans ColabOuvrir dans KaggleVoir sur GitHub

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

• Les fonctions Python, if et les listes, présentés dans Conditions et répétitions du cours Python pour l’ingénierie de l’IA en pratique.
• Comment lire un fichier CSV dans un DataFrame pandas et utiliser groupby, présentés dans Transformer avec Python du cours SQL et préparation des données pour l’IA.
• Aucune connaissance en apprentissage automatique. Cette leçon part de zéro.

Ce qu’il vous faut sur votre ordinateur (seulement pour travailler localement; le carnet ne nécessite rien de tout cela)

• Rien pour l’instant. Vous créerez le dossier de projet ~/projects/ticket-model au module 2, dans Définir une référence de base : préparer votre projet. D’ici là, ouvrez les carnets des leçons dans Colab ou Kaggle.

Le carnet a été testé dans Jupyter sur macOS. Il utilisait Python 3.14.6, pandas 3.0.6 et scikit-learn 1.9.1.

Comment vous avez appris à reconnaître une mangue mûre

Pensez à la façon dont vous avez appris à choisir une mangue mûre. Personne ne vous a donné une règle comme « une mangue est mûre quand 60 % de sa peau est jaune et qu’elle cède sous le pouce ». Vous avez plutôt vu beaucoup de mangues. Quelqu’un disait « celle-ci est mûre » ou « celle-ci n’est pas encore prête », et parfois vous en goûtiez une. Après de nombreux exemples, vous pouvez choisir une mangue mûre dans un magasin que vous n’avez jamais visité.

Vous avez appris à reconnaître un chat de la même façon. Essayez d’écrire la règle : « quatre pattes, du poil, des oreilles pointues, une queue ». Un renard correspond aussi à cette règle, mais pas un chat aux oreilles repliées. Vous ne pouvez pas bien écrire la règle, mais vous l’utilisez tous les jours. Vous l’avez apprise à partir d’exemples, pas d’une règle.

L’apprentissage automatique donne à un ordinateur la même façon d’apprendre. Cette leçon montre ce que cela veut dire et quand c’est une bonne idée.

Deux façons de faire décider un programme

Un programme doit souvent prendre une décision : cette commande est-elle suspecte, ce message est-il un pourriel, combien de temps prendra cette livraison? Il y a deux façons de lui donner la règle.

Façon 1 : une personne écrit la règle. C’est la programmation traditionnelle. Par exemple, une boutique vérifie manuellement chaque commande de plus de 500 $. La règle tient en une ligne de code : if order_value > 500. Elle est exacte, tout le monde peut la lire, et elle change seulement quand la boutique modifie sa politique. Pour une question comme celle-ci, écrire la règle est la meilleure façon de faire.

Essayez maintenant la même chose pour les pourriels. Vous écrivez : « pourriel si le message contient le mot free (gratuit) ». Cette règle détecte « GAGNEZ un téléphone gratuit ». Mais elle classe aussi « Le stationnement gratuit est-il ouvert le dimanche? » comme pourriel et manque « Montres à bas prix, achetez maintenant ». Vous ajoutez donc des mots, et chaque nouveau mot détecte davantage de messages normaux. Puis les expéditeurs de pourriels écrivent « fr3e » au lieu de « free ». Pour de vrais courriels, la liste finit par contenir des milliers de règles, et personne ne peut toutes les maintenir à jour. La régularité est trop complexe et change trop vite pour qu’une personne l’exprime en règles.

Façon 2 : le programme apprend la règle à partir d’exemples. Vous recueillez beaucoup de messages. Pour chacun, une personne indique « pourriel » ou « pas un pourriel ». Vous donnez au programme les messages et ces bonnes réponses. Le programme trouve lui-même la règle. Quand les expéditeurs de pourriels changent leurs mots, vous ajoutez de nouveaux exemples, et le programme apprend de nouveau. C’est l’apprentissage automatique.

Le schéma montre les deux façons côte à côte.

En programmation traditionnelle, une personne écrit la règle. En apprentissage automatique, l'entraînement trouve la règle dans des exemples avec leurs réponses. Le modèle fait ensuite des prédictions pour de nouveaux cas.

Description textuelle du diagramme

La boîte de gauche représente la programmation traditionnelle. Une personne écrit les règles, par exemple « si la valeur de la commande dépasse 500 $ ». Les règles et un nouveau cas entrent dans le programme, qui donne une réponse.

La boîte de droite représente l’apprentissage automatique. De nombreux cas passés, chacun avec sa bonne réponse, servent à l’entraînement. L’entraînement produit un modèle : la règle apprise. Ensuite, un nouveau cas qui n’a pas encore de réponse entre dans le modèle, et le modèle donne une prédiction.

En bref, la programmation traditionnelle transforme des règles et des données en réponses. L’apprentissage automatique transforme des données et des réponses en règle, puis utilise cette règle sur de nouvelles données.

Modèle, entraînement et prédiction

Trois mots décrivent chaque système d’apprentissage automatique de ce cours. Chacun a sa place dans l’histoire de la mangue.

• Un modèle est la règle que le programme a apprise. Dans le code, c’est un objet auquel vous pouvez demander une réponse. Dans l’histoire de la mangue, c’est la sensation dans vos mains qui vous dit « mûre ».
• L’entraînement est l’étape où le programme apprend le modèle à partir des exemples. Dans scikit-learn, la bibliothèque Python de ce cours, l’entraînement correspond à la méthode fit. Dans l’histoire de la mangue, ce sont toutes les mangues que vous avez regardées et goûtées.
• Une prédiction est la réponse du modèle pour un nouveau cas. Dans scikit-learn, elle correspond à la méthode predict. Dans l’histoire de la mangue, c’est votre choix dans un nouveau magasin. Certaines personnes appellent cette étape inférence; ce cours utilise le mot prédiction.

Une prédiction est une estimation fondée sur les exemples, pas un fait. Même une personne expérimentée choisit parfois une mangue qui n’est pas mûre. Un modèle fait aussi des erreurs. Une grande partie de ce cours porte sur la façon de les mesurer honnêtement.

Un tout petit exemple : douze messages

Priya est scientifique des données. Elle montre les deux façons avec 12 courts messages inventés. Une personne a lu chaque message et écrit la bonne réponse : 1 pour un pourriel, 0 pour un message normal.

Pourriel (1)	Normal (0)
GAGNEZ un téléphone gratuit maintenant, cliquez ici	Peut-on dîner ensemble demain?
Vous avez gagné! Réclamez votre prix gratuit	Votre commande 4417 a été expédiée
Montres à bas prix, meilleur prix, achetez maintenant	Voici les notes de la réunion d’aujourd’hui
Carte-cadeau gratuite pour vous, cliquez sur le lien	Le stationnement gratuit est-il ouvert le dimanche?
Gagnez de l’argent rapidement de chez vous, cliquez maintenant	Bonne fête! À samedi
Réclamez votre prix aujourd’hui, l’offre se termine bientôt	La facture de mars est en pièce jointe

La première cellule du carnet crée ce tableau sous forme de DataFrame messages, avec les colonnes text et spam.

Façon 1 : la règle écrite. Priya écrit la règle « pourriel si le message contient free ou winner (personne gagnante) ». Elle compte ensuite combien de fois la règle donne la bonne réponse :

def rule(text):
    """Spam (1) if the message has the word "free" or "winner"."""
    text = text.lower()
    return int("free" in text or "winner" in text)


messages["rule"] = messages["text"].map(rule)
print(messages)
print("Right:", (messages["rule"] == messages["spam"]).sum(), "of", len(messages))

Le résultat :

                                       text  spam  rule
0          WIN a free phone now, click here     1     1
1   You are a winner! Claim your free prize     1     1
2        Cheap watches, best price, buy now     1     0
3    Free gift card for you, click the link     1     1
4      Earn money fast from home, click now     1     0
5   Claim your prize today, offer ends soon     1     0
6           Can we meet for lunch tomorrow?     0     0
7               Your order 4417 has shipped     0     0
8   Here are the notes from today's meeting     0     0
9      Is the free car park open on Sunday?     0     1
10      Happy birthday! See you on Saturday     0     0
11        The invoice for March is attached     0     0
Right: 8 of 12

La règle donne la bonne réponse pour 8 des 12 messages. Elle manque trois pourriels (lignes 2, 4 et 5). Elle classe le message sur le stationnement (ligne 9) comme pourriel.

Façon 2 : un modèle qui apprend à partir des mêmes 12 messages. Le carnet contient une fonction utilitaire, new_spam_model(), qui crée un modèle vide. Le modèle compte les mots de chaque message. Pendant l’entraînement, il mesure à quel point chaque mot apparaît plus souvent dans les pourriels que dans les messages normaux. Vous n’avez pas besoin de connaître les détails pour l’instant. Ce qui compte, ce sont les deux étapes :

model = new_spam_model()
model.fit(messages["text"], messages["spam"])  # training: learn from the examples

messages["model"] = model.predict(messages["text"])  # prediction
print("Right:", (messages["model"] == messages["spam"]).sum(), "of", len(messages))

Le résultat :

Right: 12 of 12

Tomás, un ingénieur en IA qui travaille avec Priya, est content : « 12 sur 12, parfait. » Priya ne l’est pas. Le modèle a vu ces 12 réponses pendant son apprentissage. Un élève qui a vu les réponses répond aussi correctement à toutes les questions. Cela ne dit rien sur ce qu’il a compris. Un test équitable utilise des messages que le modèle n’a jamais vus.

Priya écrit donc six nouveaux messages, avec leurs bonnes réponses, dans un DataFrame new. Elle essaie ensuite les deux façons :

new["rule"] = new["text"].map(rule)
new["model"] = model.predict(new["text"])
print(new)
print("Rule right:", (new["rule"] == new["spam"]).sum(), "of 6;",
      "model right:", (new["model"] == new["spam"]).sum(), "of 6")

Le résultat :

                                      text  spam  rule  model
0       Click now to claim your cash prize     1     0      1
1       Buy cheap phones, best offer today     1     0      1
2                         Lunch on Friday?     0     0      0
3                  Your parcel has shipped     0     0      0
4            Fr3e g1ft for you, click here     1     0      1
5  The notes from the meeting are attached     0     0      0
Rule right: 3 of 6; model right: 6 of 6

La règle manque les trois nouveaux pourriels, car aucun ne contient « free » ou « winner ». L’expéditeur a même écrit « Fr3e » pour contourner ce type de règle. Le modèle combine plusieurs indices, comme « click » (cliquer), « claim » (réclamer), « prize » (prix) et « cheap » (à bas prix). Un seul mot modifié ne l’arrête donc pas.

Omar, le gestionnaire de produit, demande : « Donc, un modèle est toujours meilleur qu’une règle? » Non. Six messages, c’est très peu, et ce résultat tient en partie à la chance. Un vrai filtre antipourriel apprend à partir de millions de messages, et il fait encore des erreurs. La différence importante est la façon d’améliorer chaque approche. Pour améliorer le modèle, vous lui donnez plus d’exemples. Pour améliorer la règle, une personne doit écrire plus de règles.

L’apprentissage automatique que vous connaissez déjà

Vous utilisez l’apprentissage automatique plusieurs fois par jour. Dans chaque cas, un programme a appris à partir de nombreux exemples, et chaque exemple avait la bonne réponse.

Votre filtre antipourriel a appris à partir de messages que des personnes ont marqués comme pourriels. Un service de films ou de musique vous suggère quoi regarder ensuite. Il a appris des choix de millions de personnes après les mêmes films. Une application de cartes vous indique votre heure d’arrivée. Elle a appris à partir de trajets passés sur les mêmes routes, avec leurs durées réelles. Votre banque peut envoyer une alerte de fraude pour un paiement inhabituel par carte. Elle a appris à partir de paiements passés qui se sont révélés frauduleux. La saisie semi-automatique de votre téléphone suggère le prochain mot. Elle a appris à partir de textes tapés par des personnes, où le mot suivant était la bonne réponse.

Un exemple est différent. Une application de photos peut regrouper les photos d’un même visage avant que vous lui donniez des noms. Personne ne lui a donné les bonnes réponses. Elle rassemble les visages semblables, et vous ajoutez les noms plus tard. C’est un deuxième type d’apprentissage automatique, expliqué dans L’apprentissage non supervisé.

Système	Les exemples dont il apprend	La bonne réponse dans chaque exemple
Filtre antipourriel	Courriels passés	Pourriel ou non, indiqué par des personnes
Suggestions de films	Ce que les personnes ont regardé	Ce qu’elles ont choisi ensuite
Heure d’arrivée	Trajets passés	La durée réelle du trajet
Alerte de fraude	Paiements passés par carte	Fraude ou non, déterminé plus tard
Saisie semi-automatique	Textes tapés par des personnes	Le mot suivant
Groupes de visages dans les photos	Photos	Aucune : l’application regroupe les visages semblables, et vous ajoutez les noms

Quand l’apprentissage automatique aide et quand il n’aide pas

Tomás demande : « Alors, pourquoi ne pas utiliser l’apprentissage automatique pour tout? » Parce qu’un modèle demande du temps et se trompe parfois. Quelqu’un doit recueillir les exemples et leurs réponses, entraîner le modèle, le tester et l’expliquer. Il faut aussi vérifier qu’il fonctionne encore le mois suivant. Cet effort en vaut la peine seulement dans les bonnes situations.

L’apprentissage automatique est un bon choix quand ces quatre conditions sont vraies :

1. La régularité est trop complexe pour l’exprimer en règles, comme pour les pourriels ou une mangue mûre.
2. Des exemples existent, généralement avec la bonne réponse. Sans exemples, il n’y a rien pour apprendre.
3. La décision se répète souvent. Un filtre antipourriel décide pour chaque courriel. Créer un modèle qu’on utilise une seule fois en vaut rarement la peine.
4. Certaines erreurs sont acceptables. Tous les modèles se trompent parfois. Un filtre qui manque un pourriel sur cent reste très utile.

L’apprentissage automatique est un mauvais choix quand une de ces conditions est vraie :

• La réponse est déjà connue. « Combien de billets sont arrivés le mois dernier? » demande un décompte, pas une prédiction.
• Une règle simple donne la réponse exacte. « La commande dépasse-t-elle 500 $? » demande order_value > 500. Un modèle peut seulement être moins exact.
• Il n’y a pas d’exemples, par exemple pour un produit qui n’a pas encore été lancé.
• Chaque erreur est inacceptable, ou chaque réponse doit suivre une règle écrite. La taxe sur une facture suit la loi. Une personne l’exprime donc en règles.

Le problème de Larkfield

Larkfield est une boutique en ligne fictive de produits pour la maison et le jardin, comme dans le cours SQL. Les clients contactent le soutien, et chaque demande est un billet de soutien. Certains billets se révèlent sérieux : un agent principal doit les prendre en charge. Larkfield appelle cela une escalade. Grace, la responsable du soutien, décrit le problème : « Quand on le découvre tard, le client a déjà attendu une journée dans la file normale. Je veux que ces billets arrivent à l’équipe principale dès leur réception. »

Une personne peut-elle écrire la règle? La priorité aide : 29,1 % des billets les plus urgents (priorité 1) ont fait l’objet d’une escalade. C’est le cas de seulement 6,7 % des billets de priorité 3. Mais la plupart des escalades concernent des billets de priorité 2 et 3. Une règle fondée uniquement sur la priorité en manque donc la majorité. La régularité se cache dans plusieurs faits combinés : l’équipe, la commande, l’historique du client.

Les trois autres conditions sont aussi vraies. Larkfield dispose de deux années de billets passés et sait, pour chacun, s’il a fait l’objet d’une escalade. Environ 26 billets arrivent chaque jour. Quelques signalements erronés sont acceptables, car un agent principal vérifie chaque billet signalé. L’apprentissage automatique est donc une bonne option. Dans ce cours, vous créez ce modèle avec Priya, étape par étape. Les données sont inventées pour ce cours; elles ne concernent aucune personne réelle.

Le flux de travail en apprentissage automatique

Un modèle ne se résume pas à une étape. Il se trouve au milieu d’un travail plus long, que ce cours suit dans l’ordre :

1. Cadrez le problème : quelle décision la prédiction change et ce qu’il faut prédire exactement (module 2).
2. Recueillez les données : des cas passés avec leurs bonnes réponses. Vous avez préparé les données de Larkfield dans le cours SQL, et le module 2 les télécharge.
3. Mesurez une référence de base : la réponse la plus simple qu’un modèle doit dépasser, par exemple « signaler la priorité 1 » (module 2).
4. Décidez comment évaluer : comment juger équitablement un modèle, avant d’en créer un (module 3).
5. Entraînez un premier modèle (module 4).
6. Améliorez-le : essayez d’autres modèles et réglages, mesurez chacun et gardez ce qui aide (modules 5 et 6).
7. Comprenez-le : où il échoue, pourquoi il fait ces prédictions et si un modèle plus simple serait meilleur (module 7).
8. Préparez sa passation : enregistrez-le, documentez ses limites et planifiez les vérifications qui assurent son fonctionnement (module 8).

La liste ressemble à une ligne, mais en pratique, c’est une boucle. Un résultat faible à l’étape 6 vous ramène souvent à l’étape 2 pour obtenir de meilleures données. Une nouvelle question de l’entreprise relance la boucle. L’apprentissage automatique est itératif revient sur cette boucle.

Le flux de travail en apprentissage automatique de ce cours. Les flèches pointillées montrent que c'est une boucle : vous revenez souvent en arrière.

Description textuelle du diagramme

Le schéma montre les huit étapes du flux de travail, avec le module du cours qui enseigne chaque étape. 1, Cadrer : la décision et la cible, module 2. 2, Données : les cas passés avec leurs réponses, le cours SQL et le module 2. 3, Référence de base : la réponse la plus simple à dépasser, module 2. 4, Évaluer : décider comment juger un modèle, module 3. 5, Modèle : entraîner un premier modèle, module 4. 6, Améliorer : essayer, mesurer et garder ce qui aide, modules 5 et 6. 7, Comprendre : les erreurs, les raisons et le choix entre simple et complexe, module 7. 8, Passation : les fichiers, les limites et les vérifications, module 8.

Trois flèches pointillées reviennent en arrière. D’Améliorer à Modèle : réessayer. De Comprendre à Données : revenir chercher de meilleures données. De Passation à Cadrer : de nouvelles données et de nouvelles questions relancent la boucle.

Les études de cas à la fin du cours

Le service de soutien de Larkfield est l’exemple qui revient dans chaque leçon. Il garde un même problème en vue pendant que vous apprenez chaque idée. Le travail réel est plus varié : d’autres données, d’autres décisions, d’autres pièges. Le cours se termine donc par sept études de cas. Chacune part d’un jeu de données réel et public, dans un fichier brut, pour arriver à un résultat testé et une recommandation. Chaque résultat est expliqué.

Études de cas de ce cours

À la fin du cours, vous appliquez ce que vous avez appris à un projet réaliste, des données jusqu’à la recommandation. Terminez-en au moins une pour obtenir le certificat; les autres sont facultatives.

• Prévoir la demande de vélopartageRégression sur les locations horaires : fuites de données, séparation temporelle, modèles de Poisson et erreurs par sous-groupe.
• Estimer le prix des maisonsRégression sur de vraies ventes de maisons : cible logarithmique, emplacement, valeurs aberrantes et sens d'une erreur de 13 %.
• Prédire le défaut de paiement par carte de créditRégression logistique avec un seuil fondé sur les coûts, calibration et analyse de l'équité par sous-groupe.
• Classer une liste d'appelsUn arbre de décision qui classe les appels selon la capacité : la fuite de la durée, l'élagage, le gain (lift) et la dérive.
• Choisir un modèle pour les réadmissions à l'hôpitalComparer la régression logistique, un arbre, une forêt et le boosting selon un même protocole, puis choisir.
• Segmenter les clients d'une boutique en ligneRegrouper les clients selon la récence, la fréquence et les dépenses, puis vérifier les groupes avec leurs achats futurs.
• Trouver les types d'acheteurs en grosRegroupement sur des données de dépenses asymétriques : mise à l'échelle, piège du coefficient de silhouette, ACP et étiquette existante.

Les courtes descriptions utilisent des mots enseignés plus tard dans le cours, comme régression, regroupement (clustering) et seuil. Pour l’instant, lisez la liste comme une carte du chemin à venir.

Chaque étude de cas est aussi un projet de portfolio : un projet à mettre dans un dépôt public et à présenter en entrevue. Vous pouvez les ouvrir à tout moment, mais elles utilisent l’ensemble du cours. La plupart des apprenants les commencent donc après le module 8. Pendant votre apprentissage, certaines leçons présentent un court encadré Voir de bout en bout. Il vous dirige vers l’étude de cas où vous voyez l’idée de la leçon appliquée à des données réelles.

Exercices guidés : une règle ou des exemples?

1. Ouvrez le carnet dans l’encadré Faire cette leçon dans un carnet en haut de cette page.
2. Exécutez les cellules de préparation. La cellule de données se termine par Ready: train 16939 rows (1983 escalated), valid 1179 (183), test 1002 (157). (Prêt : entraînement, 16 939 lignes, dont 1 983 transférées au niveau supérieur; validation, 1 179, dont 183; test, 1 002, dont 157).
3. Exécutez les sections 1 à 5. Comparez chaque sortie avec le petit exemple ci-dessus.
4. Dans la section 5, regardez le taux de transfert au niveau supérieur pour chaque priorité. Vous devriez voir 0.291, 0.120 et 0.067.
5. Dans la section 6, lisez les six tâches ci-dessous.
6. Pour chaque tâche, écrivez "rule" (règle) ou "examples" (exemples) dans le dictionnaire ways.
7. Exécutez la cellule de vérification. Elle affiche Check passed (vérification réussie) quand les six réponses sont bonnes.
8. Si elle affiche Not yet (pas encore), demandez-vous pour chaque tâche : peut-on écrire la règle exacte en quelques lignes?

Les six tâches :

1. Offrir la livraison gratuite pour toute commande de plus de 50 $.
2. Lire les codes postaux écrits à la main sur des colis.
3. Suggérer des films à une personne selon ce que des personnes aux goûts semblables ont regardé.
4. Ajouter la taxe de vente à une facture.
5. Estimer l’heure d’arrivée d’un taxi dans la circulation urbaine.
6. Vérifier qu’un nouveau mot de passe compte au moins 12 caractères.

Afficher la réponse

Tâche	Méthode	Pourquoi
1. Livraison gratuite au-delà de 50 $	Règle	La règle est exacte et tient en une ligne.
2. Codes postaux écrits à la main	Exemples	Personne ne peut écrire une règle pour toutes les écritures, mais beaucoup de codes postaux numérisés ont les bons chiffres associés.
3. Suggestions de films	Exemples	Les goûts sont trop complexes à décrire par une règle, et le service possède des millions d’historiques de visionnement.
4. Taxe de vente	Règle	La loi donne la règle exacte, et aucune erreur n’est acceptable.
5. Heure d’arrivée d’un taxi	Exemples	La circulation est trop complexe à décrire par une règle, et les trajets passés ont leurs durées réelles.
6. Longueur du mot de passe	Règle	len(password) >= 12 est exact.

À vous de jouer : apprenez au modèle un nouveau type de pourriel

Changez une seule chose : le pourriel. Dans la section 7 du carnet, le modèle rencontre un nouveau type de pourriel qu’il n’a jamais vu : « Your holiday voucher is waiting, reply today » (Votre bon de vacances vous attend, répondez aujourd’hui). Il répond 0, normal. Avec une règle écrite, vous écririez maintenant une nouvelle règle. Avec l’apprentissage automatique, vous ajoutez des exemples.

Écrivez deux nouveaux pourriels sur des bons, comme le ferait une personne qui envoie des pourriels, chacun avec la réponse 1. Ajoutez-les aux 12 exemples, entraînez un nouveau modèle et interrogez-le de nouveau. Avant de l’exécuter, faites une prédiction : deux exemples suffiront-ils?

Afficher un exemple de réponse

more_examples = pd.DataFrame({
    "text": [
        "Your holiday voucher is ready, reply YES today",
        "Reply YES to get your voucher",
    ],
    "spam": [1, 1],
})
bigger = pd.concat([messages[["text", "spam"]], more_examples], ignore_index=True)
model2 = new_spam_model()
model2.fit(bigger["text"], bigger["spam"])
print("The new model says:", model2.predict([tricky])[0])

La sortie :

The new model says: 1

Deux exemples ont suffi ici, car ils partagent des mots avec le nouveau message (« holiday », « voucher », « reply », « today »). La cellule de vérification soumet aussi un message normal au nouveau modèle : « Congratulations on your new job! See you at the party » (Félicitations pour votre nouvel emploi! À bientôt à la fête). Il répond encore 0. Personne n’a écrit de règle : les exemples ont enseigné la règle.

Erreur courante

Un modèle pour une réponse qu'une règle donne déjà

Symptôme : Tomás veut utiliser l’apprentissage automatique partout. Il entraîne un modèle pour dire si une commande dépasse 500 $. Le modèle apprend à partir de neuf exemples de commandes, chacun avec la bonne réponse. Il copie la réponse de l’exemple de commande le plus semblable. Tomás le teste sur quatre nouvelles commandes :

from sklearn.neighbors import KNeighborsClassifier

orders = pd.DataFrame({"order_value": [120, 260, 380, 455, 470, 560, 610, 750, 900]})
orders["above_500"] = (orders["order_value"] > 500).astype(int)
copycat = KNeighborsClassifier(n_neighbors=1)  # copies the answer of the most similar order
copycat.fit(orders[["order_value"]], orders["above_500"])

check = pd.DataFrame({"order_value": [490, 505, 520, 640]})
check["rule"] = (check["order_value"] > 500).astype(int)
check["model"] = copycat.predict(check[["order_value"]])
print(check)

La sortie :

   order_value  rule  model
0          490     0      0
1          505     1      0
2          520     1      1
3          640     1      1

Le modèle dit qu’une commande de 505 $ ne dépasse pas 500 $.

Cause : l’exemple le plus semblable à 505 est 470, donc le modèle copie « ne dépasse pas ». Un modèle ne fait qu’approximer une règle à partir d’exemples. Ici, on connaissait la règle exacte, et le modèle n’en était qu’une moins bonne copie.

Solution : demandez d’abord si une personne peut écrire la règle exacte. Si oui, écrivez la règle : order_value > 500 ne se trompe jamais, ne coûte rien à entraîner et reste lisible pour tout le monde. Utilisez l’apprentissage automatique seulement quand la règle est trop complexe à écrire et que des exemples avec réponses existent.

Conséquence dans le travail en IA : utiliser un modèle quand une règle suffit ajoute des erreurs, des coûts et du travail. Quelqu’un doit l’entraîner, le tester et expliquer ses erreurs, pour une réponse qui était déjà exacte. Les équipes qui commencent par « quel modèle? » plutôt que « avons-nous besoin d’un modèle? » construisent souvent ce genre de système.

Vérification des connaissances

Vérifiez votre compréhension

Dans vos mots, quelle est la différence entre écrire les règles et l'apprentissage automatique? Utilisez les mots modèle, entraînement et prédiction.

Afficher la réponse

En programmation traditionnelle, une personne écrit la règle, et le programme l’applique à de nouvelles données. En apprentissage automatique, le programme apprend la règle à partir d’exemples accompagnés des bonnes réponses. Cette étape est l’entraînement, et la règle apprise est le modèle. Ensuite, le modèle donne une prédiction pour chaque nouveau cas. Pour améliorer une règle écrite, une personne écrit plus de règles. Pour améliorer un modèle, vous lui donnez plus d’exemples ou de meilleurs exemples.

Vérifiez votre compréhension

Une boutique veut savoir si un client a 18 ans ou plus, à partir de la date de naissance dans son compte. Devrait-elle entraîner un modèle? Pourquoi?

Afficher la réponse

Non. La réponse découle exactement d’une valeur connue : il suffit de comparer la date de naissance avec la date d’aujourd’hui. Une règle donne la bonne réponse chaque fois, et tout le monde peut la vérifier. Un modèle ne ferait qu’approximer la règle. Il pourrait se tromper près du 18e anniversaire, comme le modèle de Tomás pour une commande de 505 $.

Vérifiez votre compréhension

Un modèle a répondu correctement aux 12 messages utilisés pour son apprentissage. Pourquoi cela ne suffit-il pas pour lui faire confiance?

Afficher la réponse

Le modèle a vu les bonnes réponses de ces 12 messages pendant l’entraînement, donc il peut les répéter. Cela ne dit rien sur les nouveaux messages, alors que c’est pour eux qu’on utilise le modèle. Vous devez le tester sur des exemples qu’il n’a jamais vus, comme Priya avec six nouveaux messages. Le module 3 montre comment bien le faire.

Récapitulatif

• En programmation traditionnelle, une personne écrit la règle. En apprentissage automatique, le programme apprend la règle à partir d’exemples accompagnés des bonnes réponses.
• L’entraînement (fit) produit un modèle à partir d’exemples. Une prédiction (predict) est la réponse du modèle pour un nouveau cas. Une prédiction peut être fausse.
• Sur 12 messages, une règle écrite de détection des pourriels a donné 8 bonnes réponses. Elle a manqué les trois nouveaux pourriels. Un modèle entraîné sur les mêmes exemples les a détectés. Il a aussi appris un nouveau type de pourriel grâce à deux exemples de plus.
• Utilisez l’apprentissage automatique quand le motif est trop complexe à décrire par une règle, que des exemples existent, que la décision se répète et que certaines erreurs sont acceptables. Quand une règle donne la réponse exacte, écrivez la règle.
• Larkfield veut envoyer immédiatement à l’équipe senior les billets qui nécessiteront un transfert au niveau supérieur. Le motif se trouve dans plusieurs faits combinés, et deux années de billets contiennent la réponse. Ce cours construit ce modèle en suivant le flux de travail, du cadrage à la passation, sous forme de boucle.

Ensuite, vous verrez comment un programme apprend à partir d’exemples avec les bonnes réponses, comme un enfant apprend les noms des couleurs.

Leçon suivante : L'apprentissage supervisé