Dans cet article, je passe en revue les principaux modèles de Machine Learning qu’on utilise en pratique. Ces modèles de Machine Learning expliqués simplement te donnent l’intuition de chaque algorithme : l’idée centrale, ce qu’il prédit et dans quel cas l’utiliser.
À la fin, tu les essaieras tous en quelques lignes de code avec scikit-learn.
Tous les modèles de Machine Learning se classent en deux grandes familles : supervisé ou non supervisé. Un modèle supervisé est lui-même soit un modèle de régression, soit un modèle de classification.
Il existe aussi une troisième famille, l’apprentissage par renforcement : un agent apprend par essais et erreurs, comme dans un jeu vidéo. On ne la traite pas ici.
Voyons ce que signifient ces termes, et quels modèles entrent dans chaque catégorie.
Modèles de Machine Learning d’apprentissage supervisé
L’apprentissage supervisé consiste à apprendre à une fonction à associer une entrée à une sortie, à partir d’exemples connus (des paires entrée-sortie).
Par exemple, avec un jeu de données de deux variables, l’âge (entrée) et la taille (sortie), tu peux entraîner un modèle supervisé à prédire la taille d’une personne à partir de son âge.
Avec ce modèle, tu peux répondre à des questions comme : quelle est la taille d’un enfant de 8 ans ?
L’apprentissage supervisé compte deux sous-catégories :
- la régression, quand la sortie est une valeur continue (une taille, un prix, une température) ;
- la classification, quand la sortie est une catégorie (spam ou non, malade ou non, espèce d’une fleur).
Régression
Dans les modèles de régression, la sortie est continue. Voici les plus courants.
Régression linéaire
L’idée de la régression linéaire est de trouver la droite qui s’ajuste le mieux aux données. Ses extensions sont la régression linéaire multiple (trouver le plan qui s’ajuste le mieux quand il y a plusieurs variables) et la régression polynomiale (trouver la courbe qui s’ajuste le mieux).
Pour la voir en action, lis Régression linéaire avec Python, puis son application sur un cas réel avec scikit-learn.
Arbre de décision (Decision Tree)
Les arbres de décision sont un modèle populaire, utilisé en recherche opérationnelle, en planification stratégique et en Machine Learning. Un arbre se lit comme une suite de questions : chaque rectangle ci-dessus est un nœud, et les derniers nœuds, où la décision est prise, sont les feuilles.
Les arbres de décision sont intuitifs, faciles à construire et faciles à interpréter. En revanche, plus un arbre est profond, plus il colle aux données d’entraînement et moins il généralise sur des données nouvelles : c’est le surapprentissage (overfitting). On limite donc sa profondeur avec le paramètre max_depth. Un arbre seul est aussi souvent moins précis que les modèles qui suivent.
Random Forest (forêt d’arbres décisionnels)
Une forêt aléatoire (Random Forest) est une technique d’apprentissage ensembliste qui s’appuie sur des arbres de décision. Le principe :
- on construit de nombreux arbres, chacun entraîné sur un échantillon tiré au hasard dans les données d’origine ;
- à chaque étape de chaque arbre, on ne considère qu’un sous-ensemble de variables choisi au hasard ;
- la prédiction finale est la moyenne des prédictions des arbres (régression) ou le vote majoritaire (classification).
Quel est l’intérêt de cette méthode ? Les erreurs d’un arbre individuel se compensent : la majorité l’emporte, ce qui réduit le risque d’erreur.
Par exemple, ci-dessus, le troisième arbre prédit 0. Mais si on s’en remet au vote majoritaire des 4 arbres, la valeur prédite est 1. C’est la puissance des forêts aléatoires.
Gradient Boosting (XGBoost, LightGBM)
Le Gradient Boosting est une autre technique ensembliste qui s’appuie sur des arbres. Mais au lieu de construire des arbres indépendants, il les construit à la suite : chaque nouvel arbre, petit, corrige les erreurs des précédents.
XGBoost, LightGBM et CatBoost en sont les implémentations les plus connues. Ces modèles sont parmi les plus performants sur les données tabulaires, et ils servent aussi bien à la régression qu’à la classification.
Réseaux de neurones (Neural Networks)
Un réseau de neurones est un modèle organisé en plusieurs couches, inspiré du cerveau humain. Comme les neurones de notre cerveau, chaque cercle ci-dessus représente un nœud. Les cercles bleus forment la couche d’entrée (input layer), les cercles noirs les couches cachées (hidden layers) et les cercles verts la couche de sortie (output layer). Chaque nœud des couches cachées applique une fonction aux données qu’il reçoit, jusqu’à la sortie.
Les réseaux de neurones sont très mathématiques, je n’entre donc pas dans les détails ici. Pour comprendre leur fonctionnement pas à pas, lis l’article Comprendre les réseaux de neurones.
Classification
Dans les modèles de classification, la sortie est discrète : une catégorie parmi un nombre fini de possibilités. Voici les plus courants.
Régression logistique
Malgré son nom, la régression logistique est un modèle de classification. Elle ressemble à la régression linéaire, mais elle sert à modéliser la probabilité d’un nombre fini de résultats, le plus souvent deux (spam ou non, malade ou non).
Son équation est construite pour que la sortie reste toujours entre 0 et 1 (voir ci-dessous). Tu peux donc la lire comme une probabilité : au-dessus de 0,5, le modèle prédit la classe 1.
Support Vector Machine (SVM)
Un Support Vector Machine (SVM, en français « machine à vecteurs de support ») est une technique de classification supervisée. Elle peut devenir assez compliquée, mais son idée de base est intuitive.
Imagine deux classes de données. Beaucoup de frontières peuvent les séparer, mais une seule maximise la marge, c’est-à-dire la distance entre la frontière et les points les plus proches de chaque classe (voir ci-dessous). Cette frontière s’appelle un hyperplan, et les points les plus proches sont les vecteurs de support.
Avec un « noyau » (kernel), le SVM sait aussi tracer des frontières courbes quand les classes ne se séparent pas par une droite.
Naive Bayes
Naive Bayes est un autre classificateur très utilisé en Data Science. Son principe vient du théorème de Bayes :
Il calcule la probabilité qu’un élément appartienne à une classe, à partir des probabilités observées dans les données. Il est dit « naïf » parce qu’il suppose que les variables sont indépendantes entre elles. C’est rarement vrai, mais le modèle fonctionne souvent très bien et il est très rapide : il est classique pour les filtres anti-spam et la classification de textes.
k plus proches voisins (k-NN)
Pour classer un nouveau point, l’algorithme des k plus proches voisins regarde ses k voisins les plus proches dans les données d’entraînement, puis retient la classe majoritaire. Il n’y a pas d’entraînement à proprement parler : le modèle mémorise les données.
Comme il repose sur des distances, pense à mettre tes variables à la même échelle avant de l’utiliser. Pour le coder pas à pas, lis l’algorithme des k plus proches voisins.
Arbre de décision, Random Forest, réseau de neurones
Ces modèles suivent la même logique que celle vue précédemment. La seule différence : la sortie est une catégorie (discrète) plutôt qu’une valeur continue.
Modèles de Machine Learning d’apprentissage non supervisé
Contrairement à l’apprentissage supervisé, l’apprentissage non supervisé travaille sur des données sans étiquettes (sans labels). Il n’y a pas de bonne réponse connue : le modèle cherche tout seul une structure dans les données et fait apparaître des groupes ou des tendances.
Les deux grandes méthodes sont le regroupement (clustering) et la réduction de dimension.
Regroupement (clustering)
Le clustering regroupe les points de données qui se ressemblent en clusters. On l’utilise souvent pour la segmentation de clients, la détection de fraudes et la classification de documents.
Les techniques courantes sont les k-means, le clustering hiérarchique, le clustering par décalage moyen (mean shift) et le clustering basé sur la densité (DBSCAN). Chacune trouve les clusters à sa façon, mais toutes visent le même objectif. Avec les k-means, tu dois choisir à l’avance le nombre de clusters k.
Réduction de dimension
La réduction de dimension consiste à réduire le nombre de variables d’un jeu de données tout en gardant l’essentiel de l’information. Il y a deux approches : la sélection de variables (on élimine celles qui servent peu) et l’extraction de variables (on en crée de nouvelles, moins nombreuses).
Analyse en composantes principales (PCA)
La méthode la plus connue est l’analyse en composantes principales (ou PCA, pour Principal Component Analysis). Dans son sens le plus simple, elle projette des données de dimension élevée (par exemple 3 dimensions) sur un espace plus petit (par exemple 2 dimensions).
Attention : le PCA ne conserve pas tes variables d’origine. Il crée de nouvelles variables, les composantes principales, qui sont des combinaisons des anciennes et sont classées selon la quantité d’information (la variance) qu’elles conservent. C’est pratique pour visualiser des données en 2D ou accélérer l’entraînement d’un modèle.
Essayer ces modèles avec scikit-learn
Tous ces modèles s’utilisent de la même façon avec scikit-learn : fit() pour entraîner, predict() pour prédire et score() pour évaluer. Essayons les modèles de classification sur un jeu de données médical (569 tumeurs, 30 mesures chacune, à classer en bénigne ou maligne).
Les modèles sensibles à l’échelle des variables (régression logistique, SVM, k-NN et réseau de neurones) sont précédés d’un StandardScaler dans un pipeline.
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.neural_network import MLPClassifier
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
modeles = {
"Régression logistique": make_pipeline(StandardScaler(), LogisticRegression()),
"SVM": make_pipeline(StandardScaler(), SVC()),
"Naive Bayes": GaussianNB(),
"k plus proches voisins": make_pipeline(StandardScaler(), KNeighborsClassifier()),
"Arbre de décision": DecisionTreeClassifier(random_state=42),
"Random Forest": RandomForestClassifier(random_state=42),
"Gradient Boosting": GradientBoostingClassifier(random_state=42),
"Réseau de neurones": make_pipeline(StandardScaler(), MLPClassifier(max_iter=1000, random_state=42)),
}
for nom, modele in modeles.items():
modele.fit(X_train, y_train)
print(f"{nom:<24}{modele.score(X_test, y_test):.3f}")Régression logistique 0.979
SVM 0.972
Naive Bayes 0.958
k plus proches voisins 0.958
Arbre de décision 0.951
Random Forest 0.965
Gradient Boosting 0.958
Réseau de neurones 0.972Pour un modèle de classification, score() renvoie la proportion de bonnes prédictions (l’accuracy) sur les données de test. Ici, tous les modèles dépassent 95 %. Les écarts sont faibles et mesurés sur un seul découpage des données : ne conclus donc pas trop vite qu’un modèle est meilleur qu’un autre. Pour comparer sérieusement, utilise la validation croisée avec cross_val_score().
Faisons la même chose pour la régression, sur un jeu de données de 442 patients (prédire l’évolution d’une maladie). Ici, score() renvoie le coefficient de détermination R² : plus il est proche de 1, meilleur est le modèle.
from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
X, y = load_diabetes(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
modeles = {
"Régression linéaire": LinearRegression(),
"Arbre de décision": DecisionTreeRegressor(max_depth=3, random_state=42),
"Random Forest": RandomForestRegressor(random_state=42),
"Gradient Boosting": GradientBoostingRegressor(random_state=42),
}
for nom, modele in modeles.items():
modele.fit(X_train, y_train)
print(f"{nom:<22}{modele.score(X_test, y_test):.3f}")Régression linéaire 0.485
Arbre de décision 0.365
Random Forest 0.456
Gradient Boosting 0.424Le modèle le plus simple, la régression linéaire, obtient le meilleur score. Un modèle plus complexe n’est donc pas toujours meilleur, surtout quand les données sont peu nombreuses. Commence toujours par un modèle simple et ne le complexifie que s’il en vaut la peine.
Enfin, voici les deux modèles non supervisés sur les 150 fleurs du jeu de données iris (4 mesures par fleur) : les k-means pour former 3 groupes, puis le PCA pour passer de 4 à 2 dimensions.
import numpy as np
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
X, _ = load_iris(return_X_y=True)
kmeans = KMeans(n_clusters=3, n_init=10, random_state=42)
groupes = kmeans.fit_predict(X)
print("Taille des groupes :", np.bincount(groupes))
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X)
print("Avant :", X.shape, "Après :", X_2d.shape)
print("Variance conservée :", pca.explained_variance_ratio_.sum().round(3))Taille des groupes : [62 50 38]
Avant : (150, 4) Après : (150, 2)
Variance conservée : 0.978Les k-means ont trouvé trois groupes sans aucune étiquette. Et en passant de 4 à 2 dimensions, le PCA conserve environ 98 % de l’information (de la variance) : on peut donc représenter ces fleurs sur un graphique en 2D sans presque rien perdre.
Conclusion
Évidemment, chaque modèle de Machine Learning devient complexe dès qu’on l’étudie en détail. Mais tu as maintenant l’essentiel de chaque famille : la régression et la classification en supervisé, le clustering et la réduction de dimension en non supervisé.
Retiens surtout qu’il n’existe pas de modèle universel. Commence simple (régression linéaire ou logistique, arbre de décision), compare plusieurs modèles sur tes données, puis complexifie si besoin. Pour construire un projet complet pas à pas, lis ensuite Apprendre le Machine Learning avec Python.
Tous ces modèles reposent sur Python et Pandas. Avant de les entraîner sur tes propres données, assure-toi de bien maîtriser ces bases : le cours Python pour la Data Science de DataXp te les fait pratiquer avec des exercices corrigés dans le navigateur, et une partie est gratuite pour tester.
Merci pour cet article clair et détaillé sur les modèles de Machine Learning ! J’ai particulièrement apprécié les exemples concrets qui aident à mieux comprendre les concepts. Hâte de lire plus sur les applications pratiques de ces modèles !
Bonjour,
Merci pour cet article dans la partie Naive Bayes, il y’a un mot “qui” qui se répète. Je vous mets la phrase en question
“L’idée qui qui se cache derrière est inspirée du théorème de Bayes :
Merci Babacar, c’est corrigé 🙂