Pour commencer avec le machine learning avec Python, choisissez une petite tâche, séparez les données d’entraînement et de test, puis comparez un modèle simple à une référence de base. Vous n’avez pas besoin de louer un GPU pour le premier exercice. Dans ce guide, nous allons créer un classificateur complet sur CPU, interpréter ses erreurs et décider à quel moment il est pertinent de changer d’infrastructure.
L’objectif est d’obtenir une expérience que vous pouvez reproduire et expliquer. Réussir une prédiction isolée est moins utile que de savoir quelles données le modèle a vues, comment il a été évalué et où il échoue.
Que faut-il apprendre en premier en machine learning avec Python
Un projet d’apprentissage supervisé comporte des entrées, appelées attributs, et une réponse connue, appelée cible. Dans l’exemple de cet article, les attributs sont des mesures de fleurs et la cible est l’espèce. Le modèle apprend une relation à l’aide de l’ensemble d’entraînement, puis tente de classer les exemples qui ont été mis de côté.
Avant de choisir une bibliothèque, formulez la question à laquelle vous souhaitez répondre :
| Tâche | Type de réponse | Première expérience possible |
|---|---|---|
| Classer une observation | Une catégorie | Régression logistique ou arbre de décision |
| Estimer une quantité | Un nombre | Régression linéaire et analyse des erreurs |
| Trouver des groupes sans étiquettes | Regroupements | Une méthode de clustering et l’inspection des groupes |
| Travailler avec des images ou du langage à grande échelle | Représentations et prédictions plus complexes | Une bibliothèque de deep learning adaptée, après avoir défini l’évaluation |
Ne choisissez pas un réseau de neurones uniquement parce qu’il semble plus avancé. Si une solution simple résout la tâche dans les limites du coût et du délai nécessaires, elle constitue une référence importante pour toute alternative ultérieure.
Préparez un environnement isolé
Vous avez besoin d’une installation de Python compatible avec scikit-learn et d’un accès au terminal. Créez un dossier de travail et un environnement virtuel pour éviter les conflits avec d’autres projets :
python -m venv .venv
Sur macOS ou Linux, activez-le avec source .venv/bin/activate. Dans Windows PowerShell, utilisez .venv\Scripts\Activate.ps1, conformément aux politiques locales du terminal. Installez ensuite la bibliothèque et enregistrez les versions :
python -m pip install scikit-learn
python -m pip freeze > requirements.txt
Utilisez python3 à la place de python si tel est le nom de l’exécutable sur votre ordinateur. Le fichier de dépendances aide à recréer l’environnement ; conservez également la version de Python, le code et la configuration de l’expérience.
Un premier modèle complet : classification de fleurs
Le jeu de données Iris de scikit-learn contient 150 observations, quatre attributs numériques et trois classes. Il est petit et adapté à l’apprentissage du flux de travail, mais ne démontre pas qu’un système est prêt pour des données réelles.
Enregistrez le code ci-dessous sous le nom exemplo_iris.py et exécutez python exemplo_iris.py. Il utilise 120 observations pour l’entraînement et 30 pour le test. La division stratifiée maintient la représentation des classes ; la graine fixe permet de reproduire la même division.
import platform
from time import perf_counter
import sklearn
from sklearn.datasets import load_iris
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=42, stratify=y
)
models = {
"baseline": DummyClassifier(strategy="most_frequent"),
"logistica": make_pipeline(
StandardScaler(), LogisticRegression(max_iter=1000)
),
}
for name, model in models.items():
start = perf_counter()
model.fit(X_train, y_train)
train_seconds = perf_counter() - start
pred = model.predict(X_test)
print(name, "acuracia=", round(accuracy_score(y_test, pred), 3),
"f1_macro=", round(f1_score(
y_test, pred, average="macro", zero_division=0
), 3))
print("matriz de confusao:", confusion_matrix(y_test, pred).tolist())
print("tempo de treino (s):", round(train_seconds, 6))
print("Python:", platform.python_version(),
"scikit-learn:", sklearn.__version__)
Le DummyClassifier fournit une comparaison qui n’apprend pas de relation entre les attributs et la classe. Avec la stratégie utilisée ici, il prédit la classe la plus fréquente dans l’ensemble d’entraînement. Si un modèle plus élaboré n’améliore pas une telle référence, examinez les données, l’objectif et l’évaluation avant de consacrer davantage de ressources. Consultez les stratégies dans la documentation de DummyClassifier.
La régression logistique reçoit les données via un Pipeline : d’abord la standardisation, puis le classificateur. Les transformations sont ajustées lors de l’entraînement puis réappliquées au test. Cela évite de calculer l’échelle à partir d’informations qui devraient être réservées à l’évaluation, une forme courante de fuite de données. La documentation sur les bonnes pratiques de scikit-learn explique cette précaution.
Comment interpréter la sortie sans se tromper
Lors de l’exécution de cet exemple sur CPU, avec Python 3.14.4 et scikit-learn 1.9.1, nous avons obtenu les résultats ci-dessous. Ce sont les résultats de l’exercice et de cette répartition des données, pas une promesse pour un autre jeu de données.
| Modèle | Exactitude sur le test | F1 macro |
|---|---|---|
| Référence de la classe la plus fréquente | 0,333 | 0,167 |
| Standardisation + régression logistique | 0,933 | 0,933 |
La matrice du second modèle était [[10, 0, 0], [0, 9, 1], [0, 1, 9]] : deux des 30 fleurs du test ont été confondues entre les deux dernières classes. C’est plus informatif que de dire simplement que le modèle a correctement prédit environ 93 % des cas.
L’exactitude indique la proportion de prédictions correctes dans l’ensemble évalué. Le F1 macro calcule le F1 de chaque classe et en fait une moyenne sans accorder plus de poids à la classe la plus fréquente. La matrice de confusion montre quelles classes ont été confondues. Utilisez ces trois lectures pour comprendre le comportement, plutôt que de rechercher uniquement le chiffre le plus élevé.
Le temps affiché correspond uniquement au temps d’entraînement de cette exécution sur votre ordinateur. Sur un jeu de données aussi petit, il varie selon la machine et le bruit de mesure. N’utilisez pas ce chiffre pour promettre des économies dans le cloud ou comparer CPU et GPU.
Le résultat sur Iris ne doit pas non plus devenir une attente de précision pour votre produit. Avec vos propres données, la distribution, la qualité des étiquettes et le coût des erreurs peuvent être totalement différents. Une erreur rare peut être plus importante que des dizaines de prédictions faciles correctes.
Avant de changer d’algorithme, répondez aux questions suivantes :
- Le modèle a-t-il dépassé la référence de base en utilisant exactement le même test ?
- Quelle classe concentre les erreurs et quel est leur impact sur la tâche ?
- Les entrées contiennent-elles des informations qui ne seraient disponibles qu’après la prédiction ?
- Le test représente-t-il de nouveaux exemples ou contient-il des doublons et des observations liées à l’entraînement ?
- Les performances se maintiennent-elles sur d’autres répartitions valides des données ?
De l’exercice à un jeu de données réel
La répartition aléatoire est pratique pour Iris. Elle peut être inadaptée si vous prédisez des événements futurs, avez plusieurs lignes par client ou rencontrez des copies de la même observation. Dans ces cas, envisagez une séparation temporelle ou par groupes, selon la manière dont le modèle sera utilisé. Le paramètre random_state ne corrige pas une répartition conceptuellement erronée. La référence de train_test_split décrit les contrôles disponibles pour cette répartition simple.
Réservez la validation au choix des configurations et conservez un test final distinct. Si vous consultez le test à plusieurs reprises pour décider du prochain ajustement, il commence à influencer vos choix. Pour un petit projet, un tableau de suivi des expériences est déjà utile :
| Élément | À noter |
|---|---|
| Données | Origine, date, taille, colonnes et règle d’exclusion |
| Répartition | Temporelle, par groupes ou aléatoire ; graine lorsque applicable |
| Modèle | Algorithme, paramètres et version des dépendances |
| Évaluation | Métrique principale, erreurs par classe et comparaison avec la référence |
| Exploitation | Temps, mémoire, taille de l’artefact et coût mesuré |
| Décision | Ce qui s’est amélioré et le problème qui reste ouvert |
Lorsque vous remplacez Iris par votre propre tableau, validez les types, les champs manquants et les catégories avant l’entraînement. Conservez les transformations avec le modèle afin que la prédiction utilise la même préparation des données. Une colonne dont l’unité a changé peut causer des problèmes même si le code continue de s’exécuter.
Quand un GPU aide — et quand il n’aide pas
L’exemple de ce guide fonctionne sur CPU. Ajouter une carte à la machine ne fait pas automatiquement en sorte que tout le code scikit-learn l’utilise. Le projet documente la prise en charge des GPU pour un ensemble limité d’estimateurs et de configurations, y compris au moyen d’entrées et d’options spécifiques. Vérifiez le chemin exact de l’algorithme choisi.
Un GPU mérite une expérimentation lorsqu’il existe une implémentation compatible et une charge de travail capable d’en tirer parti, comme certains entraînements de réseaux neuronaux ou le traitement par lots. Même dans ce cas, le gain doit compenser le transfert des données, la préparation de l’environnement et le coût de l’infrastructure.
| Situation observée | Prochaine action recommandée |
|---|---|
| Peu de données et entraînement rapide sur CPU | Privilégier la qualité des données et l'évaluation |
| La lecture ou la préparation consomme la majeure partie du temps | Mesurer le stockage, le chargement et les transformations |
| Algorithme sans voie compatible avec le GPU | Revoir la bibliothèque ou conserver le CPU |
| L'entraînement compatible avec le GPU occupe une grande partie du cycle | Exécuter un test contrôlé sur la configuration envisagée |
| Grand modèle ou volume élevé d'inférences | Mesurer la mémoire, la latence et la concurrence avec la charge réelle |
Comparez le temps total nécessaire pour obtenir un résultat utile, et pas seulement l'exécution d'une opération. Incluez l'installation, le transfert, l'entraînement, la validation, le stockage et les périodes d'inactivité. Une alternative plus rapide par époque peut être moins bonne si elle exige davantage d'essais pour atteindre la qualité requise.
Lorsque le projet atteindra cette étape, Flatkey Cloud GPU permet d'évaluer des options de location de GPU NVIDIA. Vérifiez la configuration, la région, la disponibilité et les conditions pour la charge envisagée. Prévoyez la taille du jeu de données, la bibliothèque, la mémoire nécessaire et l'objectif du test ; ce tutoriel ne nécessite pas de louer un GPU pour être terminé.
Avant de mettre le modèle en service
Définissez le format d'entrée accepté, le comportement à adopter pour les champs non valides et la manière de suivre les erreurs après la publication. Conservez ensemble la version du modèle et la préparation des données. Testez une prédiction avec des données représentatives hors du notebook avant d'envisager le passage à l'échelle.
Si la prochaine étape consiste à servir un modèle de langage avec votre propre infrastructure, le guide de déploiement de vLLM traite d'un autre type de charge. Ne confondez pas un petit classificateur tabulaire avec l'exploitation d'un LLM : les exigences en matière de mémoire, d'évaluation et de serveur sont différentes.
Questions fréquentes
Ai-je besoin d'un GPU pour apprendre le machine learning avec Python ?
Non. L'exemple présenté peut être exécuté sur CPU. Choisissez une infrastructure plus importante lorsqu'il existe un goulot d'étranglement mesuré et une implémentation capable d'en tirer parti.
Pourquoi utiliser une référence de base avant un modèle plus complexe ?
Elle montre ce qu'il est possible d'obtenir avec une règle simple. Cela permet d'évaluer si le modèle a appris quelque chose d'utile et si la complexité supplémentaire est justifiée.
La même graine garantit-elle le même résultat dans tous les environnements ?
Elle fixe les choix aléatoires contrôlés par ce paramètre. Enregistrez également les versions et l'environnement ; des différences d'implémentation et d'exécution peuvent affecter les résultats. Ne confondez pas la reproductibilité d'une répartition avec une garantie universelle de performance.
Quel est le prochain projet après Iris ?
Choisissez une petite tâche avec des données que vous comprenez, une cible vérifiable et un critère de réussite. Répétez le processus : référence, répartition correcte, modèle, analyse des erreurs et mesure. Cette habitude est la base pour progresser en machine learning avec Python sans augmenter les coûts avant que cela ne soit nécessaire.
