Travail final

Après les études de cas
environ 4 h

Ce que vous saurez faire

Appliquez chaque module du cours à une nouvelle décision. Vous entraînez un petit réseau et lui faites reconnaître ses incertitudes. Vous présentez ses résultats pour qu’une autre personne puisse les reproduire. Ensuite, vous montrez que vous savez lire un transformeur : ses formes, son attention et son coût d’exécution.

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

Vous avez terminé les modules 1 à 7. Chaque partie ci-dessous nomme les leçons qu’elle utilise.
Vous n’avez pas besoin des études de cas pour ce travail. Le certificat exige d’en terminer au moins une.
Votre projet ticket-router fonctionne : data/ et ticketnet.py provenant de get_data.py, et PyTorch dans votre environnement virtuel ou dans Colab. Si quelque chose ne fonctionne pas, exécutez python get_data.py --reset (Installer PyTorch).
Créez un nouveau dossier dans votre projet pour ce travail : assignment/. Placez-y tous les scripts, fichiers et rapports.
Vous pouvez faire les parties 1 à 5 dans un carnet (notebook) Jupyter, localement, dans Colab ou dans Kaggle. La partie 6 exige le téléchargement de SmolLM2-135M (environ 270 Mo) et environ 1 Go de mémoire libre.
Testé avec Python 3.12, PyTorch 2.14.1 (CPU) et transformers 5.19.0 sur macOS.

La décision : confier les billets incertains à une personne

Amira a ajouté le routeur à l’application de soutien. Il envoie immédiatement chaque nouveau billet de soutien à une équipe. Grace aime cette rapidité, mais une chose l’inquiète : « Quand le routeur se trompe, le billet attend des heures dans la mauvaise file. Quand il hésite, je préfère qu’une personne le lise. »

Grace fixe donc une règle. Le routeur peut confier au plus 1 nouveau billet sur 20 (5 %) à une personne pour un routage manuel. Tous les autres billets vont directement à l’équipe que le routeur choisit. Omar pose la question qui détermine si cela en vaut la peine : « Combien de billets iront encore à la mauvaise équipe? »

Priya vous demande de construire le routeur avec un réseau de neurones, comme dans ce cours. Vous devez répondre à Omar avec des preuves. Tomás propose un raccourci : « Entraînez-le, puis choisissez le seuil sur les données de test pour atteindre exactement 5 %. » Vous verrez dans la partie 4 pourquoi ce n’est pas permis.

Les billets sont synthétiques : un modèle de langage les a rédigés pour ce cours. Aucun client réel.

Partie 1 : les formes d’abord

Utilise Tenseurs et formes et La propagation avant.

Construisez le vocabulaire uniquement à partir des billets d’entraînement, avec Vocab (fréquence minimale de 2). Notez sa taille.
Créez les tenseurs de sac de mots pour les données d’entraînement, de validation et de test. Affichez chaque forme.
Créez un BagOfWordsNet avec 32 neurones cachés. Faites-y passer les 8 premiers billets de validation et affichez la forme après chaque couche.
Dans assignment/REPORT.md, sous Shapes (formes), expliquez chaque dimension de chaque forme affichée en une ligne. Comptez les paramètres à la main. Vérifiez votre compte avec count_parameters.

Partie 2 : entraîner trois tailles et garder la meilleure époque

Utilise La boucle d’entraînement, Lots, époques et validation, Limiter le surapprentissage et state_dict() de Enregistrer et examiner les résultats.

Écrivez votre propre boucle d’entraînement dans assignment/train.py, avec les cinq étapes dans l’ordre. N’appelez pas ticketnet.train; vous pouvez en copier le code. Utilisez Adam avec un taux d’apprentissage de 0,001, des lots de 64, mélangés à chaque époque, et une graine de 0.
Après chaque époque, mesurez la perte et l’exactitude d’entraînement et de validation en mode évaluation, sans gradients. Consignez une ligne par époque.
Arrêt anticipé : gardez une copie des poids de l’époque ayant la plus faible perte de validation. Arrêtez après 3 époques sans amélioration de la perte de validation (une patience de 3), ou après 30 époques. À la fin, chargez les meilleurs poids. Copiez-les avec copy.deepcopy(model.state_dict()) : un simple model.state_dict() continue de changer pendant l’entraînement du modèle.
Entraînez de la même façon des réseaux avec 32, 64 et 128 neurones cachés.
Choisissez selon une règle écrite avant de regarder : prenez le plus petit réseau dont la meilleure perte de validation est à moins de 0,005 de la plus faible. Un petit réseau coûte moins cher à exécuter et à expliquer; il gagne donc en cas d’égalité.
Tracez la perte d’entraînement et de validation du réseau choisi. Indiquez la meilleure époque.

Partie 3 : un seuil pour l’incertitude

Utilise La perte : à quel point le réseau se trompe-t-il? et Le compromis entre précision et rappel du cours d’apprentissage automatique.

La confiance du réseau pour un billet est sa probabilité la plus élevée après softmax (conversion des scores en probabilités). Un billet dont la confiance est inférieure à un seuil va à une personne.

Calculez la confiance pour chaque billet de validation.
Trouvez le seuil : la valeur la plus élevée, arrondie à 3 décimales, sous laquelle tombent au plus 5 % des billets de validation.
Présentez les résultats de validation : le nombre de billets confiés à une personne, l’exactitude sur les billets routés automatiquement et le nombre d’erreurs du réseau que la personne intercepte.
Répondez à Omar en deux phrases : sur 1 000 nouveaux billets, combien environ vont à une personne et combien vont à la mauvaise équipe?

Partie 4 : le résultat de test, une seule fois

Utilise Données d’entraînement, de validation et de test du cours d’apprentissage automatique.

Avant d’ouvrir les données de test, écrivez sous Frozen choices (choix figés) dans votre rapport : la taille du réseau, la meilleure époque, la taille du vocabulaire et le seuil. Faites un commit (enregistrement dans Git) du fichier, ou sauvegardez une copie avec l’heure.
Exécutez le réseau choisi sur les données de test une seule fois. Présentez les mêmes chiffres qu’à l’étape 3 de la partie 3, ainsi que l’exactitude globale.
Comparez le test à la validation. Si la proportion de billets confiés à une personne dépasse 5 %, dites-le clairement. Expliquez pourquoi un seuil choisi sur 600 billets peut donner une proportion différente sur 600 nouveaux billets. Répondez ensuite à Tomás : pourquoi ne devez-vous pas modifier le seuil sur les données de test maintenant?
Proposez ce que Grace devrait faire si la proportion reste supérieure à 5 % sur les nouveaux billets. Par exemple : vérifier les premières semaines de billets réels et choisir un nouveau seuil sur ces données, jamais sur les données de test.

Partie 5 : rendre les résultats reproductibles

Utilise Enregistrer et examiner les résultats.

Sauvegardez le state_dict du réseau choisi, le vocabulaire (sous forme de liste de jetons) et le seuil dans assignment/.
Écrivez assignment/predict.py. Il charge les trois fichiers dans un nouveau processus, route les billets de validation et affiche combien vont à chaque équipe ou à une personne.
Vérifiez que le nouveau processus donne les mêmes prédictions que votre carnet pour les 600 billets de validation.
Entraînez de nouveau la taille choisie avec les graines 1, 2 et 3. Présentez la meilleure exactitude de validation de chacune : de combien varie-t-elle?
Rédigez assignment/EXPERIMENT.md comme dans la leçon : question, code et versions, réglages, matériel, données (avec le SHA-256 de chaque fichier de données), résultats, limites. hashlib.sha256(Path("data/train.csv").read_bytes()).hexdigest() en calcule un; comparez-le avec C06/data/SHA256SUMS dans le dépôt des laboratoires.

Partie 6 : une présentation annotée d’un transformeur

Utilise L’attention étape par étape, Les blocs du transformeur, Position et masquage, Entraînement et inférence et Les coûts de l’inférence.

Rédigez assignment/WALKTHROUGH.md. Une personne qui connaît Python, mais pas les transformeurs, doit pouvoir le suivre.

L’attention à la main. Choisissez 3 jetons et donnez à chacun une requête, une clé et une valeur de 2 nombres (vos propres nombres). Calculez les scores, divisez par √2, appliquez softmax et calculez les sommes pondérées. Montrez chaque nombre. Faites ensuite le même calcul avec PyTorch et montrez que les résultats concordent à 4 décimales.
Le masque causal. Appliquez un masque causal à votre exemple. Montrez les scores masqués et les nouveaux poids. Expliquez en deux ou trois phrases pourquoi un modèle qui apprend à prédire le prochain jeton ne doit pas voir les jetons futurs pendant l’entraînement.
Les formes de SmolLM2. Chargez SmolLM2-135M. Choisissez votre propre requête (prompt) au sujet d’un billet de Larkfield. Affichez les fragments de jetons et leurs identifiants, la forme de la sortie du plongement (embedding), la forme de l’état caché après les blocs et la forme des logits (scores bruts). Expliquez chaque dimension. model(**inputs, output_hidden_states=True) renvoie aussi .hidden_states : 31 tenseurs de la même forme. Le premier est la sortie du plongement; le dernier est l’état caché après les 30 blocs et la normalisation finale.
Un jeton à la fois. Générez 10 jetons en choisissant toujours le plus probable, avec votre propre boucle (pas seulement generate). Montrez les 3 prochains jetons les plus probables et leurs probabilités à la première étape.
Le coût. Pour votre requête et les 10 jetons, calculez à la main la taille du cache KV en fp32 (la formule de la leçon), ainsi que la mémoire des poids en fp32 et en bf16. Dites ensuite pourquoi entraîner ce modèle sur votre ordinateur demanderait beaucoup plus de mémoire que l’exécuter.
Ce que l’attention ne vous dit pas. En trois à cinq phrases : que peuvent suggérer les poids d’attention sur les mots qui influencent une sortie, et pourquoi ne donnent-ils pas une explication complète?

Ce qu’il faut remettre

Le dossier assignment/ contenant :

train.py, predict.py et le carnet ou les scripts de la partie 6;
le réseau, le vocabulaire et le seuil sauvegardés;
REPORT.md avec ces sections :

# Larkfield ticket router: report
## Shapes                       (Part 1: every shape explained, the parameter count by hand)
## Training                     (Part 2: the three sizes, best epochs, the choice and the rule)
## Curves                       (Part 2: the loss plot of the chosen network)
## Cut-off for a person         (Part 3: the cut-off and the validation numbers)
## Frozen choices               (Part 4: written before the test)
## Test result                  (Part 4: once; comparison with validation; the answer to Tomás)
## Repeatability                (Part 5: fresh-process check, the seed spread)
## Limits                       (synthetic tickets, one language, what the router cannot know)

EXPERIMENT.md et WALKTHROUGH.md.

Vérifiez votre travail

Une personne qui révise le travail note chaque élément démontré, partiellement démontré ou pas encore démontré, avec une raison. Pour terminer le cours, vous devez démontrer les quatre éléments obligatoires.

Des formes de tenseurs correctes (obligatoire) : chaque forme des parties 1 et 6 est affichée et expliquée, et le compte manuel des paramètres concorde.
Une boucle d’entraînement reproductible (obligatoire) : votre propre boucle suit les cinq étapes dans l’ordre; predict.py donne des prédictions identiques dans un nouveau processus; les variations selon la graine sont présentées.
Des résultats d’entraînement et de validation séparés (obligatoire) : la taille et le seuil sont choisis uniquement sur la validation, les choix sont figés avant le test et le test est utilisé une seule fois.
Une explication claire de l’attention et de l’inférence (obligatoire) : le calcul manuel concorde avec PyTorch, le masque causal est expliqué, les formes et les coûts de SmolLM2 sont corrects et les limites des poids d’attention sont indiquées.

Afficher les chiffres clés pour vérifier vos résultats

Avec la graine 0 et PyTorch 2.14.1 sur un processeur. Vos chiffres peuvent varier légèrement sur d’autres ordinateurs et versions.

Vocabulaire de 2 864 mots. Entraînement (4696, 2864), validation (600, 2864), test (600, 2864). Le réseau de 32 neurones compte 91 845 paramètres; celui de 64 neurones, 183 685; celui de 128 neurones, 367 365.
Meilleure perte de validation : 32 neurones, 0,0632 (époque 15); 64 neurones, 0,0630 (époque 11); 128 neurones, 0,0665 (époque 12). La règle choisit 32 neurones (à moins de 0,005 de la plus faible).
Seuil de 0,771. Validation : 29 billets (4,8 %) vont à une personne; exactitude sur les billets automatiques de 99,5 % (3 erreurs); la personne intercepte 6 des 9 erreurs du réseau.
Test, une seule fois : 36 billets (6,0 %) vont à une personne, au-dessus des 5 % de Grace. Exactitude sur les billets automatiques de 98,9 % (6 erreurs); exactitude globale de 96,7 %.
Graines 1, 2 et 3 : meilleures exactitudes de validation de 97,8 %, 98,3 % et 98,3 %.
Partie 6 : le cache KV de SmolLM2 occupe 46 080 octets par jeton en fp32. Les poids occupent 538 Mo en fp32 et 269 Mo en bf16.

Récapitulatif

Vous avez transformé un réseau en une décision sur laquelle une équipe peut compter. Vous avez choisi sa taille et son seuil uniquement sur la validation. Vous avez présenté le résultat de test une seule fois, même quand il n’atteignait pas une cible. Vous avez rendu le résultat reproductible dans un nouveau processus. Vous avez aussi lu un transformeur, des petits tenseurs jusqu’à un véritable modèle préentraîné, avec ses coûts et ses limites. Si vous n’en avez pas encore fait, choisissez une étude de cas pour le certificat : Classer des images de vêtements, Réseau profond ou gradient boosting?, Faire le réglage fin d’un petit transformeur ou Entraîner un tout petit modèle de langage.