Comment entraîner votre premier modèle sur n’importe quel portable, sans GPU?

Entraîner un modèle ne commence pas par l’achat de matériel. Ça commence par une question à laquelle un programme peut apprendre à répondre à partir d’exemples. « Quel chiffre voit-on sur cette toute petite image? » est un bon point de départ : les données viennent avec une bibliothèque gratuite, la réponse se vérifie et tout le travail tient dans la mémoire d’un vieil ordinateur.

Entraîner un modèle, c’est ajuster un grand ensemble de nombres jusqu’à ce que les réponses du programme sur des exemples connus s’améliorent. Un GPU, ou processeur graphique, ne fait que calculer plus vite. Quand les données et le modèle sont petits, le processeur ordinaire de n’importe quel portable suffit amplement, et une erreur vous coûte quelques secondes, pas une facture de location.

Le projet entier, en un seul fichier

Il vous faut Python 3 et deux minutes. Les commandes ci-dessous créent un environnement séparé, pour que rien ne touche au reste de votre système.

python3 -m venv first-model
source first-model/bin/activate      # sous Windows : first-model\Scripts\activate
pip install scikit-learn

Enregistrez ce code sous le nom first_model.py, puis lancez python first_model.py.

import os
os.environ["OMP_NUM_THREADS"] = "1"   # un seul fil de processeur, volontairement
import joblib
from sklearn.datasets import load_digits
from sklearn.dummy import DummyClassifier
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier

digits = load_digits()
X, y = digits.data / 16.0, digits.target   # les pixels vont de 0 à 16; on les ramène entre 0 et 1
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=0)

baseline = DummyClassifier(strategy="most_frequent").fit(X_train, y_train)
print("toujours deviner le même chiffre :", baseline.score(X_test, y_test))

model = MLPClassifier(hidden_layer_sizes=(64,), max_iter=400, random_state=0)
model.fit(X_train, y_train)
print("petit réseau de neurones :", model.score(X_test, y_test))

joblib.dump(model, "digits.joblib")
again = joblib.load("digits.joblib")
print("le modèle rechargé est d'accord :", (again.predict(X_test) == model.predict(X_test)).all())

Le jeu de chiffres contient 1 797 images de 8 pixels sur 8, réparties en 10 classes. train_test_split en garde 360 à l’écart de l’entraînement. stratify=y veille à ce que chaque chiffre figure dans les deux piles dans la même proportion. Le MLPClassifier est un petit réseau de neurones : 64 entrées, une couche cachée de 64 unités, 10 sorties.

Ce qui a été mesuré

Ces chiffres proviennent d’une exécution unique du script compagnon plus long, 01_first_model.py, limité à un seul fil de processeur sur un ordinateur Apple M5 Max doté de 64 Go de mémoire, avec Python 3.14 et scikit-learn 1.9.1. Un portable plus ancien prendra plus de temps; ce cas n’a pas été testé ici.

Autres mesures faites ici : le fichier enregistré pèse 165 Ko, le modèle rechargé a donné la même réponse sur les 360 images de test et le programme entier a culminé à 215 Mo de mémoire. La partie la plus lente de la première exécution n’était pas du tout l’entraînement. Le démarrage de Python et le chargement des bibliothèques à partir d’un disque froid ont pris environ 50 secondes; les exécutions suivantes démarrent en une seconde ou deux.

Regardez de nouveau le tableau. Le réseau de neurones a battu le modèle en ligne droite, bien plus simple, par une seule image sur 360. Ce n’est pas une victoire significative, et la série revient sur le pourquoi dans le projet quatre. Une personne qui saute le modèle simple n’apprendrait jamais que la « vraie IA » n’a presque rien changé ici.

Pourquoi quatre habitudes comptent plus que ce modèle

Tout le reste de la série est une version plus grande de ce que font ces vingt lignes.

Les fichiers joblib utilisent le format pickle de Python, qui peut exécuter du code au chargement. N’ouvrez que ceux que vous avez créés vous-même. Le projet 14 passe à un format plus sûr.

Quand un portable ne suffit plus

scikit-learn indique clairement que ce réseau n’est pas conçu pour les grands volumes et ne prend pas en charge les GPU. Vous le dépasserez un jour, mais souvent plus tard que prévu. Les projets suivants de la série ont tous été exécutés sur une seule machine et montrent exactement où vont le temps et la mémoire. Pour l’instant, une règle pratique suffit : si une exécution se termine en quelques minutes sur votre processeur, vous n’avez encore besoin de rien d’autre.

Que faut-il changer en premier une fois que le modèle fonctionne?

Changez une chose à la fois et notez le résultat. Les bons premiers changements sont la quantité de données d’entraînement, puis la taille de la couche cachée, par exemple (16,) ou (256,). Ces deux expériences vous apprennent à quel point un problème dépend des données et à quel point il dépend de la taille du modèle.

Ensuite, cherchez quelles erreurs il commet. Affichez la confusion entre les chiffres réels et prédits avec sklearn.metrics.confusion_matrix, puis regardez les images elles-mêmes. Dans l’exécution du script compagnon, l’erreur la plus courante a été de prendre un 8 pour un 1, deux fois. Regarder les erreurs en apprend plus qu’une décimale d’exactitude de plus.

Puis remplacez les chiffres par votre propre petit tableau de données, si vous en avez un que vous pouvez utiliser. Le code change à peine, alors que les questions deviennent plus difficiles : d’où viennent les étiquettes, sont-elles justes et votre jeu de test ressemble-t-il à l’usage réel? Le projet trois porte exactement là-dessus. Avant cela, le projet deux ouvre la boîte et montre ce que l’« entraînement » change vraiment.