Aller au contenu
English

Règles et modèles ensemble

  • Leçon 12
  • 35 min
  • Module 3 : Références de base : règles et modèles classiques

Où nous en sommes

Le tableau comparatif contient des règles et trois modèles classiques. Chacun réussit là où l'autre se trompe. Dans cette leçon, les règles décident des cas certains et le modèle décide du reste. Nous empêchons aussi les deux de donner des réponses différentes au même message.

Leçon 12 sur 37 · Classification et routage de textes : envoyer chaque message au bon endroitRègles et modèles ensemble
Aperçu du cours

Ce que vous saurez faire

Utilisez des règles et un modèle ensemble, sans laisser une règle remplacer un modèle qui a raison plus souvent. Comparez chaque règle au modèle. Donnez priorité à une règle seulement si ses erreurs coûtent peu et les cas qu’elle détecte coûtent cher.

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

Le carnet (notebook) Jupyter contient toutes les cellules de code, tâches et vérifications de cette leçon. Il combine les quatre règles fortes de Grace et TF-IDF + régression logistique de trois façons. Il compare chaque règle au modèle. Il évalue les méthodes sur les données de validation, puis une fois sur les données de test. Il vous demande ensuite de créer une quatrième méthode. Ses cellules de préparation installent pandas et scikit-learn et téléchargent les données d’exercice. Aucune préparation locale n’est donc nécessaire. Environ 30 minutes.

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 35 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur (seulement pour l’étape du projet)

  • Votre dossier de projet larkroute de la dernière leçon, avec .venv actif : python -m pytest -q affiche 16 passed (16 tests réussis).

Testé sur macOS avec Python 3.12, pandas 3.1.1 et scikit-learn 1.9.1. Les commandes Windows ne sont pas testées.

Au bureau de poste, les commis formés trient maintenant bien la plupart des lettres. Ils ont appris à partir d’une année de feuilles de comptage. Mais la commis en chef veut encore garder quelques règles. L’une d’elles : « Chaque colis avec un tampon fragile va sur l’étagère réservée aux objets fragiles. » Peu importe ce que le commis pense du colis. Une assiette placée par erreur sur cette étagère coûte une minute. Un vase cassé coûte un client.

Une autre de ses anciennes règles dit : « Chaque lettre contenant le mot Paris va dans le sac pour la France. » Les commis formés font mieux que cette règle, car ils lisent l’adresse entière. Si la règle passe en premier, elle envoie de nouveau les lettres du Texas en France.

La question n’est donc pas « des règles ou un modèle ». C’est plutôt : quelle règle peut remplacer la décision du modèle, et quand?

Le problème : des règles qui rendent le modèle moins bon

Section intitulée « Le problème : des règles qui rendent le modèle moins bon »

Grace a marqué quatre règles comme fortes : menaces de poursuites ou de recours à la presse, problèmes de sécurité, compte utilisé par quelqu’un d’autre et double facturation. « Pour ces cas-là, je fais plus confiance aux règles qu’à un modèle », dit-elle. Priya construit ce que Grace demande. Si une règle forte correspond, sa destination l’emporte; sinon, TF-IDF + régression logistique décide. Le projet appelle cette méthode règles fortes + régression logistique.

Voici le résultat sur les 2 000 messages de test :

Méthode Exactitude Coût par 1 000
TF-IDF + régression logistique 0,962 296,0 $ US
règles fortes + régression logistique 0,932 443,0 $ US

Les règles auxquelles Grace fait le plus confiance rendent le modèle moins bon : 60 erreurs de plus et 147 $ US supplémentaires par 1 000 messages. Comment quatre règles soigneusement choisies peuvent-elles faire ça? Regardez deux messages où une règle forte a remplacé la bonne réponse du modèle :

  • M-100053: “I would like to return order LK-195050, as the colour is not what I expected. … Separately, I was charged twice for order LK-806352…” L’étiquette est returns_refunds, soit la première demande. Le modèle répond returns_refunds. La règle de double facturation correspond à “charged twice” et envoie le message à billing.
  • M-100516: “…the smoker box can’t arrive that day. Please arrange delivery for another day…” L’étiquette est delivery, et le modèle répond delivery. La règle de sécurité correspond à “smoker” et envoie le message à needs_person.

Le modèle a lu le message entier. La règle a lu une seule expression. En passant en premier, la règle a écarté la meilleure réponse.

Quand une règle et un modèle peuvent tous deux décider, il existe plusieurs façons de les combiner. Chacune répond différemment à la question « qui gagne quand ils ne sont pas d’accord? » :

Un organigramme. Un nouveau message mène à la question : une règle forte correspond-elle? Sinon, destination du modèle. Si oui, question suivante : la règle et le modèle sont-ils d'accord? Si oui, cette destination. Sinon, deux branches : règles en premier mène à la destination de la règle; désaccord transféré à une personne mène à une personne qui lit le message.
Règles et modèle ensemble. Quand une règle forte correspond et que le modèle est d'accord, il n'y a rien à décider. En cas de désaccord, vous devez choisir qui gagne : la règle ou une personne.
Description textuelle du diagramme

L’organigramme commence par un nouveau message et une question : une règle forte correspond-elle? Sinon, le message reçoit la destination du modèle. Si oui, une deuxième question suit : la règle et le modèle sont-ils d’accord? Si oui, le message reçoit cette destination. Sinon, il y a deux branches. Avec « règles en premier », le message reçoit la destination de la règle. Avec « désaccord transféré à une personne », une personne lit le message.

  1. Le modèle seul. Les règles ne participent pas au routage.
  2. Règles fortes en premier. La règle gagne chaque désaccord. C’est la méthode du projet.
  3. Désaccord transféré à une personne. Quand une règle forte et le modèle se contredisent, aucun ne gagne. Une personne lit le message pour 1,50 $ US.
  4. Une seule règle en premier. Une règle choisie gagne ses désaccords; le modèle décide du reste.

Il n’y a pas de bonne réponse générale. Cela dépend de la fréquence à laquelle chaque côté a raison et du coût de chaque type d’erreur. Nous mesurons donc les résultats sur les messages de validation, comme toujours.

Le test le plus juste d’une règle est le suivant. Sur les messages auxquels elle correspond, qui a raison plus souvent : la règle ou le modèle? Priya fait le compte sur les 2 000 messages de validation :

  • La règle a raison
  • Le modèle a raison
Sur les messages de validation auxquels chaque règle forte correspond (menace juridique, sécurité, compte compromis, double facturation), le modèle a raison plus souvent. C'est vrai pour les quatre règles.
Description textuelle du graphique

Un graphique à colonnes avec deux colonnes pour chacune des quatre règles fortes de Grace, sur les messages de validation correspondants. Menace de poursuites ou de recours à la presse : 36 messages; la règle a raison sur 16 (44 %), le modèle sur 34 (94 %). Problème de sécurité : 43 messages; la règle sur 30 (70 %), le modèle sur 41 (95 %). Quelqu’un d’autre a utilisé le compte (compte compromis) : 7 messages; la règle sur 4 (57 %), le modèle sur 7 (100 %). Double facturation : 75 messages; la règle sur 43 (57 %), le modèle sur 71 (95 %).

Le modèle gagne contre chaque règle. La règle de menace juridique a raison sur 16 de ses 36 messages. Sur les mêmes messages, le modèle a raison sur 34. Beaucoup de clients mentionnent un avocat ou un bureau de protection des consommateurs comme prochaine étape possible, après leur véritable demande. Les étiquettes de cette boîte de réception suivent la demande. Le modèle l’a appris à partir des messages d’entraînement. La règle ne peut pas l’apprendre.

Ensemble, les quatre règles fortes correspondent à 159 messages de validation. Sur 70 d’entre eux, la règle et le modèle se contredisent. Sur ces 70 messages, le modèle a raison 64 fois, et la règle 6 fois. La méthode « règles fortes en premier » change donc 70 décisions, dont 64 deviennent des erreurs.

Voici maintenant les quatre méthodes, évaluées sur les messages de validation. Avant de regarder, faites une prédiction : laquelle coûte le moins cher?

Les quatre méthodes sur les messages de validation. Règles en premier coûte le plus cher; transférer les désaccords à une personne coûte le moins cher.
Description textuelle du graphique

Un graphique à colonnes du coût par 1 000 messages de validation pour quatre méthodes. Le modèle seul : 472,0. Règles fortes en premier : 589,0. Désaccord transféré à une personne : 432,5. Règle de sécurité seulement en premier : 445,0.

Sur les données de validation, « règles fortes en premier » coûte le plus cher (589,0 $ US). Les comptes par règle le laissaient prévoir. « Désaccord transféré à une personne » coûte le moins cher (432,5 $ US). Cette méthode fait réviser les 70 désaccords, ce qui coûte 52,5 $ US par 1 000 messages. En échange, elle détecte quelques erreurs coûteuses du modèle. « Règle de sécurité seulement en premier » coûte aussi moins cher que le modèle seul. La prochaine section explique pourquoi.

Priya a choisi « désaccord transféré à une personne » sur les données de validation. Elle évalue maintenant les quatre méthodes sur les messages de test, une seule fois :

Méthode Validation : exactitude, coût par 1 000 Test : exactitude, coût par 1 000
Le modèle seul 0,958, 472,0 $ US 0,962, 296,0 $ US
Règles fortes en premier 0,929, 589,0 $ US 0,932, 443,0 $ US
Désaccord transféré à une personne 0,926, 432,5 $ US 0,932, 339,8 $ US
Règle de sécurité seulement en premier 0,953, 445,0 $ US 0,955, 310,0 $ US

Sur les données de test, ce choix ne tient pas. Le modèle seul coûte le moins cher (296,0 $ US). « Désaccord transféré à une personne » coûte 339,8 $ US : 61 révisions, et presque rien à détecter. Sur les données de test, le modèle a raison sur 60 des 61 désaccords. Les données de validation contenaient quelques erreurs coûteuses que les révisions ont détectées; les données de test n’en contenaient pas.

C’est un résultat honnête, mais inconfortable. Deux choses sont vraies. « Règles fortes en premier » est clairement moins bon sur les deux jeux de données. Les règles fortes ne devraient pas remplacer les décisions de ce modèle. Et le gain de « désaccord transféré à une personne » est trop faible pour être fiable. Il dépend de quelques messages coûteux. Priya inscrit les deux résultats dans le tableau comparatif et garde le modèle seul comme routeur principal.

Regardez encore la dernière ligne : « règle de sécurité seulement en premier ». Elle coûte moins cher que le modèle sur les données de validation (445,0 $ US contre 472,0 $ US). Elle coûte un peu plus cher sur les données de test (310,0 $ US contre 296,0 $ US). Pourquoi cette seule règle fait-elle tellement mieux que les quatre ensemble?

La réponse se trouve dans le tableau des coûts. Quand la règle de sécurité se trompe, un message destiné à une équipe va à needs_person. Une personne expérimentée le lit et le transfère : 2 $ US. Quand le modèle manque un véritable message de sécurité, une équipe y répond automatiquement : 40 $ US. La règle peut donc se tromper 20 fois par message de sécurité détecté sans augmenter le coût total.

Sur les données de validation, la règle a changé 15 destinations du modèle. Deux étaient de véritables messages needs_person que le modèle avait manqués (80 $ US économisés). Les 13 autres ne l’étaient pas (26 $ US perdus). Sur les données de test, le modèle avait déjà trouvé les 99 messages needs_person. La règle a donc changé 14 destinations sans rien détecter. La garantie y a coûté 14 $ US par 1 000 messages : 14 messages lus par une personne expérimentée.

Une règle peut donc passer en premier quand deux conditions sont réunies :

  • Ses erreurs coûtent peu comparativement aux cas qu’elle détecte. Un mot lié à la sécurité transféré à une personne coûte 2 $ US. Un problème de sécurité manqué coûte 40 $ US, et beaucoup plus dans la vraie vie.
  • Une personne veut une garantie, pas une moyenne. Grace peut dire à un client : « Chaque message contenant hurt ou smoke est lu par une personne expérimentée. » Un modèle ne peut pas le promettre.

La règle de double facturation échoue au premier test. Quand elle se trompe, un message de retour ou de livraison va à billing. C’est la mauvaise file d’attente : 4 $ US, ou 20 $ US si le message est urgent. Quand elle détecte un cas, elle économise les mêmes 4 $ US. Elle doit donc avoir raison plus souvent que le modèle, mais ce n’est pas le cas (57 % contre 95 %).

Voici ce que Priya et Grace conviennent, sous forme de courte liste de vérification pour toute règle utilisée avec un modèle :

  1. Comparez chaque règle au modèle sur les messages de validation auxquels elle correspond. Si le modèle a raison plus souvent, la règle ne décide pas.
  2. Donnez priorité à une règle seulement pour garantir un résultat avec des erreurs peu coûteuses, comme les mots liés à la sécurité. Notez pourquoi et vérifiez son coût à chaque nouvelle version du modèle.
  3. Utilisez les autres règles comme indicateurs ou tests, pas comme destinations. « Charged twice » peut ajouter une note pour l’équipe de facturation. Les tests des règles vérifient que l’ensemble de règles fait toujours ce qu’il annonce.
  4. Donnez à chaque règle un responsable et une raison. Le champ why (pourquoi) dans config/rules.json est le point de départ. Une règle que personne ne peut expliquer est une règle que personne ne peut supprimer sans risque.

Avec les règles à leur place, le meilleur routeur classique de Larkfield est TF-IDF + un modèle linéaire. Sur cette boîte de réception, il coûte de 175,0 $ US à 296,0 $ US par 1 000 messages de test. Une personne qui lit tout coûte 1 500 $ US.

  1. Ouvrez le carnet dans l’encadré Faites cette leçon dans un carnet Jupyter en haut de cette page.
  2. Exécutez les cellules de préparation. La cellule de données se termine par Ready: 10000 messages (6000 train, 2000 validation, 2000 test), all synthetic. (prêt : 10 000 messages, dont 6 000 d’entraînement, 2 000 de validation et 2 000 de test, tous synthétiques).
  3. Dans la section 1, exécutez la cellule. Vous voyez les quatre règles fortes de Grace.
  4. Dans la section 2, écrivez votre prédiction. Exécutez ensuite la cellule. Sur les données de validation, règles fortes en premier coûte 589.0, et désaccord transféré à une personne coûte 432.5.
  5. Dans la section 3, exécutez la cellule. Pour chaque règle forte, model right (modèle correct) est supérieur à rule right (règle correcte).
  6. Dans la section 4, exécutez la cellule. Vous voyez 159 correspondances et 70 désaccords, et le modèle a raison sur 64.
  7. Dans la section 5, exécutez la cellule de test une seule fois. Le modèle seul coûte 296.0.

Terminez maintenant l’étape du projet de ce module. Le dernier fichier, larkroute/methods/classical.py, ajoute trois méthodes à route compare : Bayes naïf, SVM linéaire et règles fortes + régression logistique. Le projet trouve chaque méthode grâce à son fichier; aucun autre fichier ne change.

  1. Dans votre dossier de projet larkroute, avec .venv actif, copiez les méthodes et leur test depuis l’instantané end-of-m03 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C36/snapshots/end-of-m03
    cp "$S/larkroute/methods/classical.py" larkroute/methods/
    cp "$S/tests/test_classical.py" tests/
  2. Exécutez les tests. La dernière ligne est 18 passed (18 tests réussis). Votre projet est maintenant identique à l’instantané end-of-m03.

    Fenêtre de terminal
    python -m pytest -q
  3. Évaluez chaque méthode de ce module sur les messages de test. Cela prend environ 15 secondes :

    Fenêtre de terminal
    route compare --methods "everything to a person,rules or a person,TF-IDF + Naive Bayes,TF-IDF + logistic regression,TF-IDF + linear SVM,strong rules + logistic regression"
    method accuracy macro-F1 takeover needs person EN FR mistakes $/1k run $/1k total $/1k ms/msg
    TF-IDF + linear SVM 0.966 0.969 1.000 1.000 0.971 0.954 175.0 0.0 175.0 0.14
    TF-IDF + logistic regression 0.962 0.965 0.917 1.000 0.966 0.952 296.0 0.0 296.0 0.14
    TF-IDF + Naive Bayes 0.943 0.945 0.917 1.000 0.952 0.922 441.0 0.0 441.0 0.02
    strong rules + logistic regression 0.932 0.923 0.917 0.970 0.928 0.944 443.0 0.0 443.0 0.16
    everything to a person 0.000 0.000 0.000 0.000 0.000 0.000 1500.0 0.0 1500.0 0.00
    rules or a person 0.555 0.625 0.833 0.818 0.577 0.503 1757.8 0.0 1757.8 0.03

    Le tableau est trié par coût total, du moins cher au plus cher. Ce sont les lignes du tableau comparatif pour ce module. La colonne ms/msg varie un peu d’une exécution à l’autre.

  4. Comparez le modèle et les règles fortes sur les messages de validation, qui servent à faire votre choix :

    Fenêtre de terminal
    route compare --split validation --methods "TF-IDF + logistic regression,strong rules + logistic regression"

    Les deux dernières lignes affichent 472.0 pour le modèle et 589.0 pour règles fortes en premier.

À vous de jouer : la règle de sécurité seulement, pour commencer

Section intitulée « À vous de jouer : la règle de sécurité seulement, pour commencer »

Grace dit : « La sécurité n’est pas négociable. Je veux qu’une personne expérimentée lise chaque message contenant un mot lié à la sécurité. Même si le modèle a généralement raison. » Dans la section 6 du carnet, écrivez safety_first(part) : la destination est needs_person (besoin d’une personne) quand la règle a safety problem (un problème de sécurité) s’applique. Sinon, utilisez la destination du modèle. Calculez ensuite safety_cost, son coût par 1 000 messages de validation. Avant de l’exécuter, faites une prédiction : plus ou moins que le modèle seul (472,0 $ US)?

Afficher la réponse
def safety_first(part):
model_pred = model.predict(part["text"])
return ["needs_person" if safety["regex"].search(t) else m for t, m in zip(part["text"], model_pred)]
safety_cost = round(rt.cost_per_1000(validation, safety_first(validation)), 1)
print(safety_cost)
445.0

Moins que le modèle seul. La règle a repéré 2 messages de sécurité que le modèle avait envoyés à une équipe (40 $ US chacun). Ses 13 erreurs de destination ne coûtent que 2 $ US chacune. Sur les messages de test, la même règle coûte 310,0 $ US, contre 296,0 $ US pour le modèle seul. Dans ce cas, le modèle avait trouvé tous les messages needs_person. La règle a donc seulement ajouté 14 lectures par une personne expérimentée. Dans les deux cas, la garantie coûte peu, parce que les erreurs de la règle coûtent peu.

Erreur courante

Changer le choix après le test

Symptôme : Priya a choisi « transférer les désaccords à une personne » sur les messages de validation. Le coût était de 432,5 $ US, contre 472,0 $ US pour le modèle seul. Sur les messages de test, le modèle seul gagne (296,0 $ US contre 339,8 $ US). Tomás dit : « C’est simple. Les données de test disent que le modèle seul est le meilleur, alors choisissons-le. »

Cause : les données de test servent à donner une mesure honnête du choix que vous avez fait, pas à faire ce choix. Si vous changez votre choix à cause du résultat du test, ces données deviennent des données de validation supplémentaires. Le score devient alors trop favorable, de la même façon, et il ne reste aucune mesure honnête. Ici, les deux jeux de données donnent aussi des résultats différents parce que l’écart est petit. Il vient de quelques messages coûteux parmi 2 000.

Solution : présentez le résultat du test pour le choix tel quel : les révisions n’ont pas été rentables sur les messages de test. Prenez ensuite la prochaine décision avec plus de preuves, pas avec les données de test. Utilisez plus de messages étiquetés, ou la validation croisée sur les messages d’entraînement. C’est ce que présente Données d’entraînement, de validation et de test. Priya conserve le modèle seul comme routeur principal, pour une raison indépendante des données de test. Le gain sur les données de validation venait de quelques messages, et la simplicité réduit les risques.

Conséquence dans le travail en IA : une équipe qui choisit le gagnant sur les données de test annonce un coût qu’elle ne retrouvera pas le mois suivant. Quand deux options sont aussi proches, le bon compte rendu dit « à peu près équivalentes, et voici pourquoi ». Il ne désigne pas de gagnant.

Vérifiez votre compréhension

Les quatre règles fortes de Grace représentent « les cas où elle fait plus confiance aux règles qu'à un modèle ». Pourtant, les règles fortes combinées à la régression logistique coûtent 443,0 $ US par 1 000 messages de test. Le modèle seul coûte 296,0 $ US. Expliquez pourquoi avec les chiffres des messages de validation.

Afficher la réponse

Quand une règle forte passe en premier, elle l’emporte sur le modèle dans chaque désaccord. Sur les messages de validation, les règles fortes s’appliquent à 159 messages et contredisent le modèle pour 70 messages. Le modèle a raison dans 64 de ces 70 cas, et la règle dans seulement 6. Les règles transforment donc 64 bonnes réponses en mauvaises réponses. Sur les messages couverts par chaque règle, le modèle a raison plus souvent que la règle. Par exemple, pour les menaces juridiques, la règle a raison dans 16 cas sur 36, et le modèle dans 34. Une règle lit une expression. Le modèle lit le message entier. Il a appris qu’une menace placée après la vraie demande ne change pas la destination.

Vérifiez votre compréhension

La règle de sécurité peut passer en premier, mais pas la règle de double facturation. Utilisez le tableau des coûts pour expliquer la différence.

Afficher la réponse

Quand la règle de sécurité se trompe, un message destiné à une équipe va à needs_person. Une personne expérimentée le transfère : 2 $ US. Quand elle repère un message de sécurité que le modèle a manqué, elle économise 40 $ US. Ses erreurs coûtent donc peu, et les cas qu’elle repère évitent des coûts élevés. Elle peut se tromper 20 fois par cas repéré sans augmenter le coût total, et elle donne une garantie à Grace. Quand la règle de double facturation se trompe, un message va dans la mauvaise file d’attente. Cela coûte 4 $ US, ou 20 $ US si le message est urgent. Un cas bien repéré économise à peu près autant. Pour être utile, elle doit donc avoir raison plus souvent que le modèle. Ce n’est pas le cas : 57 % contre 95 % sur ses messages de validation.

Vérifiez votre compréhension

Vérification pratique : votre projet est maintenant à l'étape de fin du module 3. Quelle commande affiche les six méthodes de ce module dans un seul tableau? Quelle méthode coûte le moins sur les messages de test?

Afficher la réponse

route compare --methods "everything to a person,rules or a person,TF-IDF + Naive Bayes,TF-IDF + logistic regression,TF-IDF + linear SVM,strong rules + logistic regression". Après que python -m pytest -q affiche 18 passed (18 tests réussis), le tableau présente les six lignes, triées par coût total. La moins coûteuse est TF-IDF + SVM linéaire : une exactitude de 0,966 et 175,0 $ US par 1 000 messages de test dans cette boîte de réception. La plus coûteuse est « règles ou personne », à 1 757,8 $ US.

Récapitulatif

  • Appliquer les règles fortes en premier dégrade les résultats de TF-IDF + régression logistique dans cette boîte de réception. Cette combinaison donne 0,932 et 443,0 $ US par 1 000 messages de test, contre 0,962 et 296,0 $ US. Dans les 70 désaccords sur les données de validation, le modèle a raison 64 fois.
  • Comparez chaque règle au modèle sur les messages auxquels elle s’applique. Ici, le modèle gagne pour les quatre règles fortes.
  • Une règle peut passer en premier quand ses erreurs coûtent peu et les cas qu’elle repère évitent des coûts élevés. Il faut aussi qu’une personne veuille une garantie. La règle de sécurité en est un exemple : 2 $ US par erreur, 40 $ US par cas repéré.
  • Transférer les désaccords à une personne semblait le meilleur choix sur les données de validation (432,5 $ US). Ce résultat ne s’est pas maintenu sur les données de test (339,8 $ US). Présentez le résultat du test tel quel; ne changez pas votre choix à cause de ce résultat.
  • Votre projet est à l’étape end-of-m03 : 18 tests, route explain et six méthodes dans route compare. Dans cette boîte de réception, le meilleur routeur classique est TF-IDF + un SVM linéaire : 0,966 et 175,0 $ US par 1 000 messages.

Vous pouvez maintenant créer, comparer et combiner des routeurs classiques. Mais TF-IDF traite encore « parcel » et colis comme deux mots sans lien. Il ne sait rien d’un mot qu’il n’a jamais vu. Dans le module 4, nous utilisons des modèles qui attribuent des nombres semblables à des phrases semblables, en anglais et en français.

Leçon suivante : Plongements de phrases pour la classification