Enregistrer et examiner les résultats

Ce que vous saurez faire

Produisez un résultat que quelqu’un d’autre peut reproduire. Vous enregistrez le routeur de billets de soutien pour qu’un nouveau programme donne exactement les mêmes prédictions. Vous voyez aussi ce qui doit accompagner les poids. Puis vous rédigez une fiche d’expérience qui précise ses paramètres, son matériel et ses limites.

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

Le carnet (notebook) Jupyter entraîne le routeur, l’enregistre, le recharge dans un nouveau processus Python et compare les prédictions. Il montre les deux problèmes de vocabulaire, vérifie les sommes de contrôle des données et propose l’exercice du module avec SmolLM2-135M. Environ 40 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 45 minutes

Ce que vous devez savoir

• L’entraînement avec validation et le choix de la meilleure époque, dans Lots, époques et validation.
• Le vocabulaire et le sac de mots, dans La propagation avant.
• Les graines, dans Installer PyTorch.
• Les paramètres de génération de SmolLM2 (choix glouton, température, graine), dans Entraînement et inférence.

Ce qu’il vous faut sur votre ordinateur

• Rien pour travailler dans le carnet.
• Pour travailler en local : le dossier ticket-router avec data/ et ticketnet.py, dans Installer PyTorch, et transformers pour l’exercice du module, dans Entraînement et inférence.

Testé avec Python 3.12, PyTorch 2.14.1 et transformers 5.19.0 sur le processeur d’un Mac mini. Nous avons exécuté le carnet dans Jupyter sur macOS, pas dans Colab ni Kaggle.

Un gâteau et sa recette

Une pâtissière prépare un gâteau que tout le monde adore. Deux choses lui permettent de le refaire. Elle peut congeler une tranche, ce qui conserve le gâteau, mais pas la méthode. Ou elle peut écrire la recette. Une recette utile ne dit pas seulement « farine, sucre, œufs ». Elle précise la farine, les poids, la température du four, le temps et le moule. Elle note même « mon four chauffe trop ».

Un réseau entraîné comporte les deux mêmes parties. Les poids sont la tranche congelée. La fiche qui explique comment ils ont été obtenus est la recette.

Le problème : un résultat qui existe seulement dans un carnet

Le routeur de Priya a atteint 98,3 % sur les billets de validation à l’époque 12. Ce résultat existe dans la mémoire de son carnet. Si le noyau redémarre, les poids disparaissent, et refaire l’entraînement prend du temps. Amira a besoin du routeur dans l’application de soutien, sur un autre ordinateur. Le programme n’a jamais vu le carnet de Priya. Et dans trois mois, quelqu’un demandera : « C’était 98,3 % sur quelles données, avec quel code? » Tomás a une réponse rapide : « Je vais juste vous envoyer le fichier. »

L’idée : un point de contrôle et tout ce dont il dépend

Un point de contrôle est une copie enregistrée des nombres appris par un modèle. Il permet de reprendre l’entraînement ou l’inférence. Le nom vient d’une course ou d’un jeu : un point auquel vous pouvez revenir.

Dans PyTorch, model.state_dict() renvoie les nombres appris sous forme de dictionnaire : le nom de chaque tenseur de poids et le tenseur. Priya entraîne de nouveau le routeur à sac de mots de Lots, époques et validation. Elle l’entraîne pendant 12 époques, jusqu’à sa meilleure époque. vocab, x_train, y_train, x_valid et y_valid sont créés comme dans cette leçon. Les premières cellules du carnet les créent et font les importations.

save_router.py

set_seed(0)
model = BagOfWordsNet(len(vocab))
history = train(model, x_train, y_train, x_valid, y_valid, epochs=12, log=None)
print(history[-1])
for name, tensor in model.state_dict().items():
    print(f"{name:16} {tuple(tensor.shape)}")

La sortie :

{'epoch': 12, 'train_loss': 0.0179, 'train_acc': 0.9977, 'valid_loss': 0.0633, 'valid_acc': 0.9833}
layers.0.weight  (64, 2864)
layers.0.bias    (64,)
layers.3.weight  (5, 64)
layers.3.bias    (5,)

Quatre tenseurs : la première couche (2 864 → 64) et la couche de sortie (64 → 5). Les positions 1 et 2 de layers sont ReLU et le dropout (désactivation aléatoire de neurones), sans poids. Les noms viennent des attributs de la classe. Seul du code avec les mêmes attributs peut donc les charger.

Les poids seuls ne peuvent pas acheminer un billet. La colonne 1 000 de l’entrée représente un mot précis. Le vocabulaire, dans son ordre, doit donc accompagner les poids. Et la personne qui reconstruit le réseau a besoin de sa configuration : taille du vocabulaire, taille cachée et dropout. Priya enregistre les trois :

save_router.py

Path("checkpoint").mkdir(exist_ok=True)
torch.save(model.state_dict(), "checkpoint/router.pt")                     # the weights
Path("checkpoint/vocab.json").write_text(json.dumps(vocab.itos))           # the tokens, in column order
Path("checkpoint/config.json").write_text(json.dumps({"vocab_size": len(vocab), "hidden": 64, "dropout": 0.0}))

torch.save() écrit les tenseurs dans un fichier. vocab.itos est la liste des jetons (tokens), où la position correspond au numéro de colonne. Les fichiers sont petits : router.pt fait 737 107 octets, vocab.json, 28 486 octets et config.json, 50 octets.

Vérifiez-le dans un nouveau processus

Un carnet garde en mémoire tout ce que vous avez exécuté. Un rechargement dans le même carnet prouve donc peu de choses. Le vrai test est un nouveau processus Python qui dispose seulement des fichiers. Avant d’enregistrer le modèle, Priya a aussi enregistré ses probabilités de validation dans checkpoint/valid_probs.pt, pour les comparer.

Enregistrer dans un processus, recharger dans un autre : les fichiers doivent suffire à reconstruire le réseau et à produire les mêmes prédictions.

Description textuelle du diagramme

À gauche, le processus 1 est le carnet de Priya. Il s’entraîne pendant 12 époques et atteint 98,3 % sur les billets de validation. Il enregistre les poids avec torch.save(model.state_dict()). Au milieu se trouvent trois fichiers : router.pt, vocab.json et config.json. À droite, le processus 2 est un nouveau Python. Il construit BagOfWordsNet à partir de config.json, charge les poids avec load_state_dict() et appelle model.eval(). Il prédit les 600 billets de validation et compare : 600 sur 600 sont identiques.

reload_router.py

import json, torch
from ticketnet import BagOfWordsNet, Vocab, bag_of_words, labels, load_split

config = json.load(open("checkpoint/config.json"))
vocab = Vocab([])                                        # an empty vocabulary ...
vocab.itos = json.load(open("checkpoint/vocab.json"))    # ... filled with the saved tokens, in order
vocab.stoi = {token: i for i, token in enumerate(vocab.itos)}

model = BagOfWordsNet(config["vocab_size"], hidden=config["hidden"], dropout=config["dropout"])
model.load_state_dict(torch.load("checkpoint/router.pt"))
model.eval()                                             # inference: dropout off

valid = load_split("data/valid.csv")
with torch.no_grad():
    probs = torch.softmax(model(bag_of_words(valid, vocab)), dim=1)
before = torch.load("checkpoint/valid_probs.pt")
print("same predictions:", (probs.argmax(1) == before.argmax(1)).sum().item(), "of", len(valid))
print("largest difference in a probability:", (probs - before).abs().max().item())
print("validation accuracy:", round((probs.argmax(1) == labels(valid)).float().mean().item(), 4))

La sortie de python reload_router.py :

same predictions: 600 of 600
largest difference in a probability: 0.0
validation accuracy: 0.9833

load_state_dict() copie les tenseurs enregistrés dans un réseau construit par le code. Il vérifie que chaque nom et chaque forme correspondent. Les résultats sont identiques jusqu’au dernier chiffre sur le même ordinateur. Sur un autre processeur, de minuscules différences d’arrondi dans les derniers chiffres sont possibles. Les équipes prédites ne devraient pas changer.

Notez model.eval() après le chargement. Ce routeur n’a pas de dropout actif. Mais sans eval(), un réseau avec dropout donne des réponses qui changent d’une exécution à l’autre. C’est le comportement réservé à l’entraînement de Comment les réseaux de neurones apprennent et de Diagnostiquer les problèmes d’entraînement.

Pourquoi ne pas enregistrer l’objet entier?

torch.save(model) fonctionne aussi, sans state_dict(). Il enregistre l’objet Python entier, ce qui semble plus simple. Mais le fichier contient alors une référence à la classe BagOfWordsNet dans ticketnet.py, pas le code de la classe. Priya essaie de le charger dans un nouveau processus. Elle utilise d’abord le réglage par défaut de PyTorch, puis un dossier sans ticketnet.py :

default load:       _pickle.UnpicklingError: Weights only load failed. This file …
without ticketnet:  ModuleNotFoundError: No module named 'ticketnet'

Le réglage sûr par défaut de PyTorch (weights_only=True) refuse de reconstruire des objets Python. En effet, charger un objet peut exécuter du code provenant du fichier. Même avec cette protection désactivée, l’objet exige toujours le code exact de la classe au même endroit. Si quelqu’un renomme le fichier ou modifie la classe, les anciens points de contrôle ne se chargent plus. Donc : enregistrez le state_dict et conservez le code qui construit le réseau sous contrôle de version, à côté du point de contrôle.

Le vocabulaire doit correspondre : un échec visible et un échec silencieux

Tomás envoie seulement router.pt à Amira. Elle reconstruit elle-même le vocabulaire à partir des billets d’entraînement et de validation, puis charge les poids :

size mismatch for layers.0.weight: copying a param with shape torch.Size([64, 2864]) from checkpoint, the shape in current model is torch.Size([64, 2987]).

Son vocabulaire contient 2 987 jetons, pas 2 864, donc PyTorch refuse. C’est le cas chanceux : une erreur visible. Si son vocabulaire avait la même taille, mais un autre ordre, chaque mot arriverait dans la colonne d’un autre mot. Et rien ne signalerait le problème. Priya provoque volontairement cette situation : les mêmes 2 864 jetons dans l’ordre inverse. Le réseau se charge, s’exécute et achemine correctement 24,0 % des billets de validation. C’est pire que de toujours répondre « delivery » (livraison), à 27,5 %, sans aucun message d’erreur.

Quoi noter d’autre

Les poids, le vocabulaire et la configuration reconstruisent le modèle. Pour répéter l’expérience, il faut aussi tout ce qui a produit ces poids. Il faut aussi une description honnête de ce que le résultat montre.

Contenu d'une fiche d'expérience reproductible, remplie pour le routeur de Priya. Les deux premières cartes reconstruisent le modèle; les huit permettent de répéter l'expérience.

Description textuelle du diagramme

Huit cartes, remplies pour le routeur de Priya.

• Poids : router.pt, provenant de model.state_dict(), 0,74 Mo, avec son SHA-256.
• Vocabulaire ou segmenteur en jetons : vocab.json, 2 864 jetons dans l’ordre; pour un modèle préentraîné, l’identifiant du modèle et sa révision.
• Configuration : taille cachée 64, dropout 0, Adam, taux d’apprentissage 0,001, lot 64, 12 époques.
• Graines : set_seed(0) avant le modèle et avant l’entraînement.
• Données : train.csv et valid.csv, avec leur SHA-256 provenant de SHA256SUMS.
• Code et bibliothèques : ticketnet.py, Python 3.12.13, PyTorch 2.14.1.
• Matériel : Mac mini, processeur seulement, 2 fils d’exécution.
• Évaluation et limites : 98,3 % sur 600 billets de validation; les billets sont inventés; les données de test sont encore scellées.

Pourquoi chaque carte compte :

• Les graines fixent les poids de départ et l’ordre des lots. Sans set_seed(0), une autre exécution atteint un autre résultat à l’époque 12.
• Les versions des bibliothèques peuvent modifier les réglages par défaut et les nombres. Dans une version récente, torch.load a adopté weights_only=True comme réglage par défaut. C’est pourquoi le chargement du fichier contenant l’objet entier a échoué plus haut.
• Le matériel change complètement les durées mesurées et modifie légèrement les résultats en virgule flottante. Une durée mesurée sans mention du matériel ne signifie rien.
• Les sommes de contrôle des données prouvent qu’il s’agit du même fichier, octet par octet. Une somme de contrôle est une courte empreinte calculée à partir de chaque octet; un seul caractère modifié la change. Dans le carnet, les deux fichiers correspondent au SHA256SUMS publié; celle de train.csv commence par 98487169346f8b0d.
• L’évaluation et ses limites indiquent ce que le nombre signifie : quelle partition, combien d’exemples et ce qu’il ne peut pas montrer. Un résultat de 98,3 % sur 600 billets de validation inventés ne garantit pas 98,3 % avec de vrais clients.

Pour un modèle préentraîné, l’identifiant du modèle et sa révision remplacent le fichier de vocabulaire. Le segmenteur en jetons de SmolLM2 accompagne le modèle. Fixer revision= fixe donc les poids et le segmenteur en jetons ensemble. Ajoutez le dtype (type de données), car float32 et bfloat16 donnent des sorties différentes. La leçon précédente l’a montré.

Une fiche d’expérience pour SmolLM2

Une fiche d’expérience est un court fichier texte, souvent EXPERIMENT.md, à côté du code et du point de contrôle. Voici la fiche de l’expérience de mesure du temps présentée dans la leçon précédente :

EXPERIMENT.md

# Experiment: SmolLM2-135M generation time with and without the KV cache

## Question
How long does SmolLM2-135M take to write 40 tokens on our CPU, with and
without the KV cache? Are the tokens the same?

## Model and code
- Model: HuggingFaceTB/SmolLM2-135M, revision 93efa2f097d58c2a74874c7e644dbc9b0cee75a2
- Loaded as float32 (the files on Hugging Face are bfloat16); tokenizer of the same revision
- Code: m07_smollm.py; Python 3.12, PyTorch 2.14.1, transformers 5.19.0

## Settings
- Prompt: "Larkfield is an online shop for home and garden products.
  A customer wrote: my parcel is late. The support team" (25 tokens)
- Greedy choice, 40 new tokens, use_cache=True and use_cache=False
- torch.manual_seed(0); one warm-up run, then the median of 5 runs

## Hardware
- Mac mini (Apple silicon, arm64), macOS 26, CPU only, 4 threads,
  no other heavy programs running

## Data
- None: one fixed prompt

## Results
- With the KV cache: 0.46 s. Without: 1.01 s. The 40 tokens are identical.
- Greedy text: " is very helpful. I am looking for a new parcel. I am looking for ..."
- Checksum of the 40 token IDs (first 12 hex digits of SHA-256): 8def2cec688d

## Limits
- One prompt of 25 tokens: the gap grows with longer texts; not measured here.
- One computer: other CPUs, other thread counts or a GPU give other times.
- Medians of 5 reduce timing noise from other programs; they do not remove it.
- Speed only: this says nothing about the quality of the text (a base model).

La somme de contrôle des identifiants de jetons permet de confirmer la même sortie sans comparer 40 jetons à l’œil. La section sur les limites n’est pas une excuse. Elle indique au lecteur à quelles questions le résultat répond et à quelles questions il ne répond pas.

Quand enregistrer et ce que cela coûte

Enregistrez un point de contrôle à la fin de l’entraînement. Pendant les longues exécutions, enregistrez-en aussi à la meilleure époque de validation. C’est l’arrêt précoce : garder le meilleur, pas le dernier. Gardez une fiche pour chaque résultat que quelqu’un utilisera pour agir ou citera. Enregistrez le code et la fiche dans Git avec un commit (enregistrement d’une version). Gardez les gros points de contrôle à côté, avec un nom et une somme de contrôle.

Ce que cela coûte : quelques minutes par expérience et de l’espace disque. Le point de contrôle du routeur fait 0,74 Mo; les fichiers de SmolLM2 font 269 Mo. Un point de contrôle pour poursuivre l’entraînement exige aussi l’état d’Adam, qui occupe deux fois la taille des poids. Vous pouvez omettre un point de contrôle pour un essai rapide que personne ne répétera. N’omettez pas la fiche d’un nombre qui servira à prendre une décision.

Exercice guidé : enregistrer, recharger, comparer

1. Dans le carnet, exécutez la section 1. Vous devriez voir l’époque 12 avec 'valid_acc': 0.9833 (exactitude de validation) et quatre tenseurs dans le state_dict.
2. Exécutez la cellule qui enregistre le dossier checkpoint. Vous devriez voir router.pt avec 737 107 octets.
3. Exécutez les deux cellules de la section 2. Vous devriez voir same predictions: 600 of 600 (mêmes prédictions : 600 sur 600).
4. Exécutez la section 4. Notez quel échec produit une erreur et lequel n’en produit aucune.
5. Exécutez la section 5. Vous devriez voir matches SHA256SUMS: True (correspond à SHA256SUMS : vrai) deux fois.

Afficher la réponse

Le vocabulaire construit à partir des billets d’entraînement et de validation produit une erreur visible : tailles incompatibles, 2 864 contre 2 987. Le vocabulaire inversé ne produit aucune erreur et achemine correctement 24,0 % des billets. Une vérification des formes détecte seulement le premier échec. Seule une comparaison des prédictions après le rechargement détecte les deux.

À vous de jouer : reconstruire au lieu de charger

Amira dit : « Je n’ai pas besoin de vocab.json. Je vais construire Vocab à partir du même train.csv avec min_count=2, comme Priya. » Prédisez : son réseau donnera-t-il les mêmes 600 prédictions? Expliquez ensuite quand son raccourci échoue.

Afficher la réponse

Oui, aujourd’hui. Vocab trie les jetons. Le même fichier, avec le même segmenteur en jetons et le même min_count, donne les mêmes 2 864 jetons dans le même ordre. Mais le raccourci dépend de quatre choses que personne n’a notées. Le fichier doit être identique, octet par octet (vérifiez le SHA-256), et min_count doit toujours valoir 2. Le code de tokenize() doit être inchangé, et Vocab doit toujours trier de la même façon. Une faute de frappe corrigée dans un billet peut changer le vocabulaire. Enregistrer vocab.json élimine les quatre risques pour 28 Ko.

Erreur courante

Ça fonctionnait sur mon portable

Symptôme : Tomás entraîne un routeur, voit 98 % sur son portable et envoie router.pt à Amira. Sur le serveur de soutien, le chargement échoue avec size mismatch for layers.0.weight (tailles incompatibles pour layers.0.weight). Tomás « corrige » le problème en construisant un vocabulaire de la bonne taille. Le routeur se charge maintenant, mais le serveur achemine correctement environ un billet sur quatre, et personne ne reçoit d’erreur.

Cause : le point de contrôle contenait seulement les poids. Le vocabulaire qui donne son sens à chaque colonne est resté sur le portable de Tomás. Ses graines, ses versions de bibliothèques et sa version des données y sont aussi restées. Personne n’a noté comment les 98 % ont été mesurés. Personne ne pouvait donc comparer le serveur à ce résultat.

Solution : fournissez le dossier du point de contrôle : router.pt, vocab.json, config.json, et la version du code qui construit le réseau. Ajoutez EXPERIMENT.md avec les graines, les versions, le matériel, les sommes de contrôle des données et l’évaluation. Après chaque rechargement sur une nouvelle machine, prédisez un ensemble fixe de billets dans un nouveau processus. Comparez avec les prédictions enregistrées : 600 sur 600, sinon arrêtez.

Ce que cela signifie pour un vrai service d’IA : « ça fonctionne sur ma machine » n’est pas un résultat. Un modèle est prêt à être transmis seulement lorsqu’un nouveau processus reproduit les prédictions enregistrées avec les seuls fichiers fournis.

De bout en boutClasser des images de vêtementsÉtude de cas

L’étude de cas sur les vêtements enregistre son réseau et une fiche d’expérience, puis le recharge avec des prédictions identiques.

Vérification des connaissances

Vérifiez votre compréhension

Que contient model.state_dict(), et pourquoi est-il plus sûr de l'enregistrer que l'objet modèle entier?

Afficher la réponse

Il contient les tenseurs appris, par nom. Pour le routeur : layers.0.weight (64, 2864), layers.0.bias (64), layers.3.weight (5, 64) et layers.3.bias (5). Ce sont de simples données, donc PyTorch les charge avec son réglage sûr par défaut. Tout code qui construit le même réseau peut les utiliser. Un objet entier enregistré contient une référence à sa classe. Il exige donc le code exact de la classe au même endroit, et le réglage sûr par défaut refuse de le charger.

Vérifiez votre compréhension

Prédisez : vous rechargez le routeur avec les mêmes 2 864 jetons de vocabulaire dans un ordre différent. Que se passe-t-il quand vous appelez load_state_dict(), et qu'arrive-t-il à l'exactitude?

Afficher la réponse

load_state_dict() réussit, car chaque nom et chaque forme correspondent. L’exactitude chute, car chaque mot arrive maintenant dans la colonne d’un autre mot. Avec l’ordre inversé, le routeur a acheminé correctement 24,0 % des billets de validation. C’est moins que les 27,5 % obtenus en répondant toujours « delivery ». Seule une comparaison des prédictions détecte le problème.

Exercices du module

Exercice guidé → tâche autonome. Vous avez vu Priya enregistrer, recharger et consigner le routeur, puis lu le compte rendu de l’expérience de chronométrage. Exécutez maintenant SmolLM2-135M et comparez ses sorties avec des réglages contrôlés. Rédigez vous-même le compte rendu.

1. Dans la section 6 du carnet Jupyter, chargez SmolLM2-135M avec la révision fixée, en float32.
2. Générez deux fois 40 jetons par sélection gloutonne et vérifiez que les textes sont identiques.
3. Générez deux fois 25 jetons à une température de 0,8 (top_p=0.95) avec la graine 1. Vérifiez qu’ils sont identiques.
4. Pour les températures 0,3, 0,8 et 1,2, générez 25 jetons avec les graines 1, 2 et 3. Exécutez la cellule de vérification.
5. Remplissez les quatre lignes ... de EXPERIMENT.md : la question, les réglages, une ligne de résultats par température et les limites. Exécutez la cellule de vérification.

Afficher un exemple de réponse

Sur l’ordinateur du cours, les deux répétitions ont donné des résultats identiques. Voici les neuf échantillons (les sauts de ligne sont représentés par des espaces) :

Température	Graine 1	Graine 2	Graine 3
0,3	“ is available to help. The post How to Find a Good Online Store appeared first on The Gardener’s Companion.”	“ is very helpful. I am looking for a new home. I have a 1200 sq ft house. I”	“ is very helpful and I have been able to get my parcel delivered to my house. I have a question about the”
0,8	“ is currently at my front door, and I am still waiting for their response. I am the only one with the”	“ is there to help you out. They’ve got all the right tips and tools to make it happen, and they know exactly”	“ is there to help you with the delivery. They are really friendly and supportive. It takes 2-3 hours to get”
1,2	“ is currently at my front lawn, looking at a patch on my driveway and have been asking me where to send my package”	“ is there but my parcel is not there. Can you fix my parcel to arrive to me early for delivery? The customer email”	“ took my item and returned it to me but they didn’t refund me since I’m not supposed to have it back. What”

Voici un exemple des quatre lignes du compte rendu :

## Question
How do greedy choice and sampling at three temperatures change the continuation
of one Larkfield prompt, and does each setting repeat?

## Settings
- Greedy: 40 new tokens, run twice
- Sampling: temperatures 0.3, 0.8 and 1.2, top_p 0.95, seeds 1, 2, 3, 25 new tokens each

## Results
- Temperature 0.3: two of three samples start like the greedy text ("is very helpful").
- Temperature 0.8: three different, fluent continuations.
- Temperature 1.2: three different continuations; one invents a refund story.

## Limits
- One prompt and three seeds: a description, not a measurement of quality.
- A base model: it continues the text; it does not answer the customer.
- Sampled text can differ on another processor even with the same seeds; greedy text usually matches.
- No timings: they depend on the computer and on what else runs on it.

Le carnet Jupyter remplit le modèle, la révision, les versions des bibliothèques et le matériel à partir du programme en cours d’exécution. Cela évite les erreurs de copie. La graine 1 à une température de 0,3 montre une habitude des modèles de base. Le texte se termine par une phrase qui ressemble au pied de page d’un fil Web de blogue. Les pages Web font partie de son texte de préentraînement.

Vérification du module

Vérifiez votre compréhension

Rappel : nommez les trois étapes de la vie d'un modèle préentraîné et indiquez lesquelles changent les poids. Nommez ensuite ce que le cache KV stocke.

Afficher la réponse

Le préentraînement change tous les poids à partir d’une énorme quantité de texte. L’adaptation les change un peu par réglage fin, ou pas du tout par des requêtes. L’inférence ne change rien : elle effectue seulement des propagations avant. Le cache KV stocke les clés et les valeurs de tous les jetons traités, dans chaque bloc. Ainsi, chaque étape de décodage calcule seulement le nouveau jeton.

Vérifiez votre compréhension

Expliquez ou prédisez : Amira fait les exercices du module sur un ordinateur Colab équipé d'un processeur Intel. Quels résultats devrait-elle obtenir exactement, lesquels pourraient différer, et pourquoi?

Afficher la réponse

Elle devrait obtenir le même nombre de paramètres, les mêmes formes et la même segmentation en jetons. Ces résultats dépendent seulement des fichiers du modèle à la révision fixée. Le texte obtenu par sélection gloutonne sera généralement identique. Les textes échantillonnés peuvent différer, même avec les mêmes graines. De minuscules différences d’arrondi entre processeurs peuvent changer un tirage, dont dépendent tous les jetons suivants. Ses temps seront complètement différents, car ils dépendent du matériel. C’est pourquoi le compte rendu précise le matériel. C’est aussi pourquoi il vérifie la sortie gloutonne avec une somme de contrôle, plutôt que les échantillons.

Vérifiez votre compréhension

Vérification finale : livrez une expérience reproductible. Énumérez ce que votre EXPERIMENT.md et son dossier doivent contenir pour qu'une autre personne puisse la répéter. Précisez ses limites liées au matériel et aux données.

Afficher la réponse

Le dossier contient le code (ou son commit, une version enregistrée dans Git) et le compte rendu. Le compte rendu indique la question, l’identifiant du modèle, la révision et le dtype. (Pour le routeur : router.pt, vocab.json et config.json.) Il énumère les réglages exacts : requête, sélection gloutonne ou échantillonnage, température, top_p, graines, nombre de jetons. Il indique les versions des bibliothèques (Python, PyTorch, transformers) et le matériel (processeur, CPU ou GPU, fils d’exécution). Pour les données, il indique les fichiers avec leurs sommes de contrôle SHA-256, ou « aucune : une seule requête fixe ». Il donne les résultats avec une somme de contrôle des identifiants des jetons obtenus par sélection gloutonne. Il donne aussi l’évaluation et sa taille. Limites liées au matériel : les temps et les textes échantillonnés sont valables seulement pour cet ordinateur. Un autre processeur peut changer les deux. Limites liées aux données : une seule requête donne une description, pas une mesure. Le résultat de 98,3 % du routeur vaut pour 600 billets de validation inventés. Il ne vaut ni pour de vrais clients ni pour les données de test scellées.

Récapitulatif

Cette leçon : un point de contrôle est model.state_dict() enregistré avec torch.save(). Le vocabulaire (ou l’identifiant du modèle et sa révision) et la configuration l’accompagnent. Un nouveau processus doit reproduire les prédictions : 600 sur 600, différence de 0,0. N’enregistrez pas l’objet entier. Consignez les graines, les versions des bibliothèques, le matériel et les sommes de contrôle des données dans EXPERIMENT.md. Consignez aussi l’évaluation et ses limites.

Ce module : un modèle préentraîné passe par le préentraînement, l’adaptation (réglage fin ou requêtes) et l’inférence. SmolLM2-135M est une version à grande échelle du transformeur du module 6. Il comprend 30 blocs, une attention à requêtes groupées, des plongements partagés et 134,5 millions de paramètres. La génération est une boucle de propagations avant. Le cache KV réduit le coût de chaque étape, mais consomme de la mémoire. La mémoire correspond au nombre de paramètres × le nombre d’octets. La quantification fait un compromis entre mémoire, vitesse et qualité. L’entraînement demande environ quatre fois la mémoire des poids. Les grands modèles sont donc hors de portée du matériel ordinaire.

Procédure de réinitialisation : si un carnet Jupyter donne d’autres nombres, redémarrez le noyau et exécutez toutes les cellules depuis le début. Les nombres du routeur proviennent de set_seed(0). Si le téléchargement du modèle échoue, vérifiez la connexion Internet. Dans Kaggle, activez Internet (accès Internet), puis exécutez la cellule de nouveau. Si une somme de contrôle des données est incorrecte, supprimez le dossier ticket-router et relancez la cellule de configuration. Pour recommencer les exercices, supprimez le dossier checkpoint et le fichier EXPERIMENT.md.

À suivre : les études de cas appliquent tout le cours à de vraies données ouvertes, en commençant par des images de vêtements.

Leçon suivante : Des fréquences au sens : sac de mots, TF-IDF et plongements