Comment créer votre premier modèle d’apprentissage automatique en Python (2026)

La meilleure façon de comprendre l’apprentissage automatique est de construire soi-même un modèle. Cela paraît bien moins intimidant qu’il n’y paraît — avec Python et la bonne bibliothèque, votre premier modèle fonctionnel ne nécessite qu’environ 20 lignes de code. Ce tutoriel vous accompagne étape par étape, en expliquant non seulement quoi écrire, mais aussi pourquoi.

Ce que vous allez construire

Vous allez créer un classificateur — un modèle capable de classer des éléments dans différentes catégories. Nous utiliserons le jeu de données classique destiné aux débutants, le jeu de données Iris: des mesures de fleurs d’iris (longueur et largeur des pétales et des sépales), dont l’objectif est de prédire l’espèce de la fleur. Ce jeu de données est petit, propre et intégré nativement à scikit-learn, ce qui le rend parfait pour un premier modèle.

Les cinq étapes décrites ici s’appliquent à presque tous les projets d’apprentissage automatique, quelle que soit leur ampleur.

Étape 1 : Préparer vos outils

Vous avez besoin de Python et de deux bibliothèques. scikit-learn est la bibliothèque phare — elle fournit des jeux de données, des algorithmes et des outils d’évaluation via une interface cohérente et adaptée aux débutants.

Installez-les depuis votre terminal :

pip install scikit-learn pandas

Vous pouvez écrire le code dans un simple fichier .py mais un carnet Jupyter (ou un carnet cloud gratuit comme Google Colab) est idéal pour l’apprentissage — vous exécutez le code par petits blocs et visualisez immédiatement chaque résultat.

Étape 2 : Charger les données

Chaque projet d’apprentissage automatique commence par les données. Ici, nous chargeons le jeu de données Iris intégré :

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data      # les mesures (les entrées / caractéristiques)
y = iris.target    # les espèces (les étiquettes / réponses)

print("Forme de X :", X.shape)   # (150, 4) — 150 fleurs, 4 mesures chacune
print("Classes :", iris.target_names)

Deux variables sont essentielles ici, et leur nommage suit une convention universelle :

• X contient les caractéristiques — les entrées à partir desquelles le modèle apprend (les quatre mesures).
• y contient les étiquettes — les réponses correctes (l’espèce).

Comme nous disposons des réponses, il s’agit d’un cas d’ apprentissage supervisé.

Étape 3 : Fractionner les données

Il s’agit de l’étape la plus importante pour obtenir un résultat fiable. Vous devez diviser vos données en deux parties :

• A jeu d’entraînement à partir duquel le modèle apprend.
• A jeu de test que le modèle ne voit jamais pendant l’entraînement — utilisé uniquement pour son évaluation.

Si vous effectuez l’évaluation sur les mêmes données que celles utilisées pour l’entraînement, vous ne mesurerez que la capacité de mémorisation du modèle, et non un apprentissage réel. (C’est ainsi que l’on détecte les cas de surapprentissage.)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

test_size=0.2 conserve 20 % des données pour les tests et entraîne le modèle sur les 80 % restants. random_state=42 garantit simplement que la division aléatoire est reproductible, afin d’obtenir systématiquement le même résultat à chaque exécution.

Étape 4 : Choisir et entraîner un modèle

Passons maintenant à l’apprentissage automatique proprement dit. Nous utiliserons une forêt aléatoire — un algorithme précis, fiable et adapté aux débutants (voir notre guide des algorithmes).

Dans scikit-learn, l’entraînement d’un modèle se fait en deux lignes :

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

L’appel à la méthode .fit() constitue est l’étape d’entraînement. Le modèle analyse les caractéristiques du jeu d’entraînement ainsi que leurs étiquettes, puis apprend les motifs reliant les mesures à l’espèce. scikit-learn gère entièrement les calculs mathématiques sous-jacents à cette unique ligne de code.

Étape 5 : Évaluer le modèle

Vérifions désormais dans quelle mesure le modèle a bien appris — en utilisant le jeu de test qu’il n’a jamais vu :

from sklearn.metrics import accuracy_score

predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)

print(f"Précision : {accuracy:.2%}")

.predict() demande au modèle de classer les fleurs du jeu de test ; accuracy_score compare ses prédictions aux réponses réelles. Sur le jeu de données Iris, on obtient généralement une précision comprise entre 95 % et 100 % — votre modèle identifie correctement presque toutes les fleurs qu’il n’avait jamais rencontrées auparavant.

Étape 6 : Effectuer une prédiction sur de nouvelles données

Le véritable intérêt opérationnel : utiliser le modèle sur des données entièrement nouvelles. Fournissez-lui un ensemble de mesures et il prédira l’espèce correspondante :

new_flower = [[5.1, 3.5, 1.4, 0.2]]   # mesures du sépale et du pétale
prediction = model.predict(new_flower)

print("Espèce prédite :", iris.target_names[prediction[0]])

Voilà un modèle d’apprentissage automatique complet : entraîné, évalué et capable de produire des prédictions sur des données qu’il n’a jamais rencontrées.

Le flux de travail complet

Ces cinq étapes ne constituent pas seulement un exercice — elles forment le squelette de pratiquement tous les projets d’apprentissage supervisé :

Les projets plus complexes ajoutent le nettoyage des données, la préparation des caractéristiques et l’ajustement du modèle — mais cette boucle fondamentale reste inchangée.

Où aller ensuite

Pour continuer à approfondir vos compétences :

• Essayer d’autres algorithmes — remplacer RandomForestClassifier pour LogisticRegression ou SVC et comparez. L’interface cohérente de scikit-learn rend cette opération triviale.
• Essayez d’autres jeux de données — pratiquez avec des jeux de données jeux de données gratuits qui vous intéressent.
• Apprenez la préparation des données — les données réelles sont désordonnées ; leur nettoyage et leur préparation constituent la majeure partie du travail.
• Explorez l’évaluation — la précision (accuracy) n’est qu’une métrique parmi d’autres ; apprenez à utiliser la justesse (precision), le rappel (recall) et la validation croisée (cross-validation).

Erreurs courantes qui compromettent discrètement votre premier modèle

Votre modèle s’est entraîné et a affiché un score de précision — mais un chiffre qui semble bon ne signifie pas nécessairement qu’il fonctionne correctement. Voici les pièges dans lesquels les débutants tombent le plus souvent, et tous sont faciles à éviter dès lors qu’on en connaît l’existence.

• Évaluer le modèle sur des données qu’il a déjà vues. Si vous mesurez la précision sur les données d’entraînement, vous évaluez en réalité la capacité du modèle à mémoriser les réponses. Un score de 100 % dans ce cas ne signifie rien. Évaluez toujours le modèle sur l’ensemble de test réservé lors de la division initiale des données — c’est le seul chiffre qui permette d’estimer les performances réelles.
• Fuite de données (data leakage) : laisser les données de test influencer l’entraînement. Il s’agit de l’erreur la plus dommageable et la moins évidente. Si vous normalisez, mettez à l’échelle ou remplissez des valeurs manquantes avant avant la division, des statistiques provenant de l’ensemble de test (par exemple, la moyenne d’une colonne) se retrouvent involontairement intégrées à l’étape d’entraînement, ce qui fausse artificiellement votre score. La solution consiste à respecter rigoureusement l’ordre suivant : diviser d’abord, puis appliquer la méthode fit à tout transformateur uniquement sur l’ensemble d’entraînement, et simplement appliquer (apply) ce transformateur à l’ensemble de test. La documentation de scikit-learn identifie ce problème comme l’un des pièges les plus fréquents en apprentissage automatique.
• Oublier de mettre à l’échelle les données lorsque l’algorithme en a besoin. Les modèles basés sur les distances ou les gradients (k-plus-proches-voisins, SVM, régression logistique) sont fortement perturbés lorsque l’une des caractéristiques varie entre 0 et 1 tandis qu’une autre varie entre 0 et 100 000. En revanche, les modèles basés sur les arbres (comme les forêts aléatoires) ne sont pas sensibles à cette différence d’échelle. Assurez-vous de savoir à quelle catégorie appartient votre algorithme.
• Accorder trop de confiance à la précision (accuracy) sur des données déséquilibrées. Si 95 % de vos exemples appartiennent à une même classe, un modèle qui prédit systématiquement cette classe obtiendra un score de précision de 95 %, tout en étant totalement inutile. Lorsque les classes sont déséquilibrées, consultez plutôt la justesse (precision), le rappel (recall) et le score F1 fournis par classification_report plutôt que de vous fier uniquement à la précision.

La défense la plus efficace contre les fuites de données est l’utilisation d’un Pipelinepipeline. Enchaîner le prétraitement et le modèle au sein d’un seul objet garantit que chaque transformation est automatiquement ajustée (fit) sur la bonne portion des données, à chaque fois — y compris pendant la validation croisée :

• from sklearn.pipeline import make_pipeline
• model = make_pipeline(StandardScaler(), LogisticRegression())
• Ensuite, appelez tout simplement model.fit(X_train, y_train) comme précédemment.

Une dernière habitude utile à adopter dès le début : une seule division train/test fournit une estimation bruitée. Réexécuter l’entraînement avec une autre division aléatoire peut faire varier votre score de plusieurs points. Une fois que vous vous sentez à l’aise, remplacez cette division unique par cross_val_score, qui effectue l’entraînement et l’évaluation sur plusieurs plis (folds) et renvoie la moyenne — une évaluation bien plus fiable pour déterminer si votre modèle a réellement appris quelque chose.

FAQ

Comment construire un modèle d’apprentissage automatique en Python ?

Utilisez la bibliothèque scikit-learn. Le flux de travail est le suivant : chargez vos données sous forme de caractéristiques (X) et d’étiquettes (y), divisez-les en ensembles d’entraînement et de test, créez un modèle puis appelez la méthode .fit() pour l’entraîner, évaluez-le sur l’ensemble de test, et utilisez .predict() pour effectuer des prédictions sur de nouvelles données. La réalisation d’un premier modèle tient en environ 20 lignes de code.

Quelle bibliothèque les débutants devraient-ils utiliser pour l’apprentissage automatique ?

scikit-learn. Elle propose un large éventail d’algorithmes, des jeux de données intégrés et des outils d’évaluation via une interface simple et cohérente, tout en gérant automatiquement les calculs mathématiques sous-jacents. C’est le point de départ standard avant de passer aux frameworks d’apprentissage profond.

Dois-je maîtriser les mathématiques pour construire un modèle d’apprentissage automatique ?

Non. Pour construire des modèles avec scikit-learn, il vous suffit de maîtriser les bases de Python et de comprendre le flux de travail. La bibliothèque s’occupe des aspects mathématiques. Une compréhension plus approfondie des mathématiques devient utile ultérieurement si vous souhaitez affiner vos modèles de façon experte ou mener des recherches.

Pourquoi faut-il diviser les données en ensembles d’entraînement et de test ?

Afin de mesurer réellement les performances. Si vous évaluez un modèle sur les mêmes données qu’il a utilisées pour s’entraîner, vous ne mesurez que sa capacité à mémoriser. Un ensemble de test distinct, que le modèle n’a jamais vu, permet de déterminer s’il a véritablement appris le motif sous-jacent et s’il est capable de généraliser à de nouvelles données.

Que fait la méthode model.fit() ?

.fit() représente l’étape d’entraînement. Elle fournit au modèle les caractéristiques et les étiquettes d’entraînement, ce qui incite l’algorithme à ajuster ses paramètres internes afin d’apprendre les relations entre les entrées et les réponses correctes. Une fois que .fit(), le modèle est entraîné et prêt à effectuer des prédictions.

Mon modèle atteint une haute précision — cela signifie-t-il qu’il est bon ?

Pas nécessairement. Une haute précision n’a de sens que si elle a été mesurée sur l’ensemble de test réservé (et non sur les données d’entraînement), et si vos classes sont raisonnablement équilibrées. Sur un jeu de données où une classe domine largement, un score élevé peut simplement provenir du fait que le modèle devine systématiquement la classe majoritaire. Vérifiez la précision (precision), le rappel (recall) et le score F1 à l’aide de classification_report, et assurez-vous que ce chiffre provient bien de données que le modèle n’a jamais vues pendant l’entraînement.

Comment enregistrer mon modèle entraîné et l’utiliser ultérieurement ?

Utilisez la bibliothèque Python joblib , fournie avec scikit-learn. Appelez joblib.dump(model, "model.joblib") pour écrire le modèle entraîné sur le disque, et joblib.load("model.joblib") pour le charger dans un autre script — aucun nouvel entraînement requis. Enregistrez l’ensemble du pipeline (Pipeline), et non seulement l’estimateur final, afin que vos opérations de mise à l’échelle (scaling) et de prétraitement soient conservées avec le modèle, garantissant ainsi un traitement identique des nouvelles entrées.

Comment passer d’un jeu de données intégré à mes propres données ?

Chargez vos données avec pandas — pandas.read_csv("votre_fichier.csv") — puis séparez vos colonnes d’entrée (les caractéristiques, ou « features », généralement appelées X) de la colonne que vous souhaitez prédire (la cible, ou « target », y). À partir de là, le flux de travail reste identique : division, entraînement, évaluation. Le travail supplémentaire consiste principalement au nettoyage des données : gestion des valeurs manquantes, encodage des catégories textuelles en nombres, et sélection des colonnes réellement pertinentes. C’est précisément cette étape de préparation des données qui consomme la majeure partie du temps consacré à l’apprentissage automatique dans des cas concrets.

Conclusion

Construire votre premier modèle d’apprentissage automatique est bel et bien un projet court et réalisable : installez scikit-learn, puis chargez, divisez, entraînez, évaluez et prédisez. Ces cinq étapes constituent le fondement de presque tous les projets supervisés d’apprentissage automatique que vous réaliserez.

Ne vous contentez pas de lire cet article — ouvrez un carnet de notes (notebook) et exécutez le code. Modifiez l’algorithme, essayez un autre jeu de données, provoquez volontairement des erreurs puis corrigez-les. Les concepts de l’apprentissage automatique deviennent bien plus clairs dès lors que vous avez entraîné un modèle de vos propres mains. Lorsque vous êtes prêt à aller plus loin, téléchargez un jeu de données gratuit et construisez quelque chose à votre manière.