Machine learning et deep learning : comprendre les algorithmes et coder vos premiers modèles

Le machine learning (apprentissage automatique) est une branche de l’intelligence artificielle qui permet à un programme d’apprendre à partir d’exemples : au lieu d’écrire des règles à la main, on fournit des données, et l’algorithme en déduit un modèle capable de faire des prédictions sur de nouveaux cas. Le deep learning en est une famille particulière, fondée sur des réseaux de neurones à plusieurs couches.

Ce guide s’adresse aux développeurs, analystes, étudiants et curieux qui veulent comprendre ce qu’il y a derrière ces termes et passer à la pratique. Vous y trouverez les concepts clés, les grands types d’apprentissage, les algorithmes les plus utilisés, les étapes d’un projet avec du code Python, puis une introduction aux réseaux de neurones avec PyTorch et TensorFlow.

Qu’est-ce que le machine learning ?

Le machine learning est un ensemble de méthodes qui permettent à un ordinateur d’apprendre une tâche à partir de données, sans être explicitement programmé pour chaque cas. L’algorithme analyse des exemples, en extrait des régularités sous forme de modèle mathématique, puis applique ce modèle pour prédire, classer ou regrouper de nouvelles données.

Un exemple simple : pour détecter les e-mails indésirables, un programme classique contiendrait des règles écrites à la main (« si l’objet contient tel mot, alors… »). Un modèle de machine learning, lui, reçoit des milliers d’e-mails déjà étiquetés « indésirable » ou « légitime » et apprend seul quelles combinaisons de caractéristiques distinguent les deux.

Quelques repères historiques utiles : l’expression machine learning est attribuée à Arthur Samuel à la fin des années 1950, à la même période que le perceptron de Frank Rosenblatt, ancêtre des réseaux de neurones. Le deep learning a pris son essor au début des années 2010, porté par la puissance des processeurs graphiques et les grands jeux de données, puis l’architecture Transformer, publiée en 2017, a ouvert la voie aux grands modèles de langage actuels.

IA, machine learning, deep learning : quelle différence ?

Ces trois termes sont souvent employés comme synonymes, alors qu’ils s’emboîtent :

Terme	Définition	Exemples
Intelligence artificielle	Ensemble des techniques qui permettent à une machine de simuler des capacités humaines (raisonner, percevoir, décider)	Systèmes experts, moteurs de jeu, assistants conversationnels
Machine learning	Sous-ensemble de l’IA : la machine apprend à partir de données	Prévision des ventes, score de crédit, détection de fraude
Deep learning	Sous-ensemble du machine learning : apprentissage par réseaux de neurones profonds	Reconnaissance d’images, traduction, génération de texte
NLP (traitement du langage naturel)	Domaine d’application qui traite le texte et la parole, aujourd’hui dominé par le deep learning	Analyse de sentiment, résumé, chatbots

La différence pratique entre machine learning classique et deep learning tient surtout à la nature des données. Sur des données en tableau (clients, ventes, capteurs), les algorithmes classiques comme les forêts aléatoires ou le gradient boosting sont souvent aussi performants et bien plus simples à mettre en œuvre. Sur des données non structurées (images, audio, texte), le deep learning l’emporte nettement.

Les trois grands types d’apprentissage

Apprentissage supervisé

Les données d’entraînement contiennent la réponse attendue (l’étiquette). Le modèle apprend la relation entre les caractéristiques et cette réponse. Deux familles de problèmes :

• Classification : prédire une catégorie (client qui va résilier ou non, e-mail indésirable ou non, type de pièce défectueuse).
• Régression : prédire une valeur numérique (prix d’un logement, consommation d’énergie, délai de livraison).

Apprentissage non supervisé

Les données n’ont pas d’étiquette. L’algorithme cherche lui-même des structures :

• Clustering : regrouper des clients aux comportements similaires pour une segmentation marketing.
• Réduction de dimension : résumer des dizaines de variables en quelques axes pour visualiser ou simplifier les données.
• Détection d’anomalies : repérer les transactions ou les mesures qui s’écartent de la normale.

Apprentissage par renforcement

Un agent agit dans un environnement et reçoit des récompenses ou des pénalités. Il apprend par essais et erreurs la stratégie qui maximise ses récompenses. C’est l’approche utilisée pour les jeux, la robotique ou certains systèmes d’optimisation.

À quoi sert le machine learning en entreprise ?

Le machine learning est utile dès qu’une décision répétée peut s’appuyer sur un historique de données. Les cas d’usage les plus courants :

• Commerce et marketing : prévision des ventes, recommandation de produits, segmentation de la clientèle, prédiction de la résiliation.
• Finance et assurance : détection de fraude, score de risque, repérage des déclarations atypiques.
• Industrie : maintenance prédictive à partir des capteurs, contrôle qualité par la vision, optimisation des réglages.
• Services et relation client : classement automatique des demandes, analyse du sentiment des avis, assistants conversationnels.
• Santé et recherche : aide à l’analyse d’images médicales, exploitation de grands volumes de données expérimentales.

Dans la pratique, les modèles tournent rarement sur un ordinateur portable : ils sont entraînés et déployés sur des plateformes de données ou des services cloud. Découvrir un fournisseur comme AWS, présenté dans notre guide pour débuter avec AWS, aide à comprendre comment un modèle passe du prototype à la production.

Les algorithmes de machine learning à connaître

Il n’est pas nécessaire de connaître des dizaines d’algorithmes pour commencer. Ceux-ci couvrent la grande majorité des cas pratiques :

Algorithme	Type	Points forts	Limites
Régression linéaire	Supervisé, régression	Simple, interprétable, rapide	Relations uniquement linéaires
Régression logistique	Supervisé, classification	Interprétable, bonne base de comparaison	Frontières de décision simples
Arbre de décision	Supervisé	Très lisible, pas besoin de normaliser	Surapprend facilement
Forêt aléatoire	Supervisé	Robuste, performant sans réglage fin	Moins interprétable, plus lourd
Gradient boosting (XGBoost, LightGBM)	Supervisé	Souvent le plus performant sur données en tableau	Réglages plus délicats
k plus proches voisins	Supervisé	Intuitif	Lent sur gros volumes, sensible à l’échelle
k-means	Non supervisé, clustering	Simple et rapide	Nombre de groupes à fixer à l’avance
Réseau de neurones	Supervisé ou non	Excellent sur images, texte, son	Beaucoup de données et de calcul

Notre conseil : commencez toujours par un modèle simple (régression logistique ou arbre) comme référence. Un modèle complexe ne se justifie que s’il fait nettement mieux.

Comment réaliser un projet de machine learning : les étapes

Prenons un exemple concret : prédire quels clients d’un service par abonnement risquent de résilier, à partir d’un fichier contenant l’ancienneté, le nombre de commandes, le panier moyen, le nombre de réclamations et une colonne indiquant si le client a résilié.

Étape 1 — Définir le problème et la métrique

Formulez la question précisément : « prédire, pour chaque client actif, la probabilité qu’il résilie dans les trois prochains mois ». C’est un problème de classification supervisée. Choisissez ensuite la métrique qui compte pour le métier : si les résiliations sont rares, l’exactitude (accuracy) est trompeuse, et il vaut mieux regarder le rappel (part des résiliations détectées) et la précision (part des alertes justifiées).

Étape 2 — Explorer et préparer les données avec Pandas

La préparation des données représente souvent l’essentiel du travail. Avec Pandas :

import pandas as pd

df = pd.read_csv("clients.csv")

df.info()                 # types de colonnes et valeurs manquantes
df.describe()             # statistiques de base
df["a_resilie"].value_counts(normalize=True)   # équilibre des classes

# Traitement des valeurs manquantes et des doublons
df["panier_moyen"] = df["panier_moyen"].fillna(df["panier_moyen"].median())
df = df.drop_duplicates()

# Encodage d'une variable catégorielle
df = pd.get_dummies(df, columns=["type_abonnement"], drop_first=True)

NumPy intervient en arrière-plan : les colonnes Pandas reposent sur des tableaux NumPy, que l’on manipule directement pour les calculs vectoriels et le deep learning.

Étape 3 — Séparer entraînement et test

On réserve une partie des données, que le modèle ne verra jamais pendant l’apprentissage, pour mesurer honnêtement sa performance :

from sklearn.model_selection import train_test_split

X = df.drop(columns=["a_resilie", "id_client"])
y = df["a_resilie"]

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

Le paramètre stratify=y conserve la même proportion de résiliations dans les deux jeux.

Étape 4 — Entraîner un modèle

Avec scikit-learn, tous les modèles suivent la même logique : on crée l’objet, on appelle fit() sur les données d’entraînement, puis predict() sur de nouvelles données.

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

reference = LogisticRegression(max_iter=1000).fit(X_train, y_train)
foret = RandomForestClassifier(n_estimators=300, random_state=42).fit(X_train, y_train)

Étape 5 — Évaluer et comparer

from sklearn.metrics import classification_report, roc_auc_score

for nom, modele in [("Référence", reference), ("Forêt aléatoire", foret)]:
    proba = modele.predict_proba(X_test)[:, 1]
    print(nom, "AUC :", round(roc_auc_score(y_test, proba), 3))
    print(classification_report(y_test, modele.predict(X_test)))

Le rapport affiche précision, rappel et score F1 pour chaque classe. Pour une estimation plus fiable, la validation croisée (cross_val_score) répète l’entraînement sur plusieurs découpages des données.

Étape 6 — Améliorer puis déployer

On améliore un modèle en travaillant d’abord les données (nouvelles variables pertinentes, correction d’erreurs), puis les hyperparamètres (avec GridSearchCV ou RandomizedSearchCV). Une fois validé, le modèle est enregistré et intégré dans une application, un traitement planifié ou une plateforme de données. Des outils comme MLflow suivent les versions et les expériences : nous en montrons un exemple dans notre guide pour apprendre Databricks.

Le deep learning : comment fonctionne un réseau de neurones ?

Un réseau de neurones est composé de couches :

• une couche d’entrée, qui reçoit les données (les pixels d’une image, les variables d’un client) ;
• une ou plusieurs couches cachées, où chaque neurone calcule une somme pondérée de ses entrées, puis applique une fonction d’activation (ReLU, sigmoïde, tangente hyperbolique) ;
• une couche de sortie, qui produit la prédiction (une probabilité, une classe, une valeur).

L’entraînement suit une boucle : le réseau fait une prédiction, une fonction de perte mesure l’erreur, la rétropropagation du gradient calcule comment chaque poids contribue à cette erreur, et un optimiseur (descente de gradient, Adam) ajuste les poids. Cette boucle est répétée sur l’ensemble des données pendant plusieurs époques.

Selon les données, on utilise des architectures différentes :

• Réseaux denses (perceptrons multicouches) pour les données en tableau ;
• Réseaux convolutifs (CNN) pour les images et la vidéo ;
• Réseaux récurrents (RNN, LSTM) pour les séquences, historiquement utilisés pour le texte et les séries temporelles ;
• Transformers, fondés sur le mécanisme d’attention, aujourd’hui dominants en traitement du langage et de plus en plus utilisés pour les images.

Un premier réseau avec TensorFlow (Keras)

from tensorflow import keras

modele = keras.Sequential([
    keras.Input(shape=(X_train.shape[1],)),
    keras.layers.Dense(32, activation="relu"),
    keras.layers.Dense(16, activation="relu"),
    keras.layers.Dense(1, activation="sigmoid"),
])
modele.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
modele.fit(X_train.astype("float32"), y_train, epochs=30, validation_split=0.2)

Le même réseau avec PyTorch

import torch
from torch import nn

X_t = torch.tensor(X_train.values, dtype=torch.float32)
y_t = torch.tensor(y_train.values, dtype=torch.float32).unsqueeze(1)

modele = nn.Sequential(
    nn.Linear(X_t.shape[1], 32), nn.ReLU(),
    nn.Linear(32, 16), nn.ReLU(),
    nn.Linear(16, 1),
)
perte = nn.BCEWithLogitsLoss()
optimiseur = torch.optim.Adam(modele.parameters(), lr=0.001)

for epoque in range(30):
    optimiseur.zero_grad()
    erreur = perte(modele(X_t), y_t)
    erreur.backward()
    optimiseur.step()

Keras masque la boucle d’entraînement derrière fit(), ce qui le rend très accessible. PyTorch l’écrit explicitement, ce qui offre plus de contrôle et explique sa popularité en recherche. Pensez à normaliser les variables numériques avant d’entraîner un réseau de neurones : sans cela, l’apprentissage est souvent lent ou instable.

Les erreurs fréquentes en machine learning (et comment les éviter)

En formation, ces erreurs reviennent chez presque tous les débutants :

Erreur	Conséquence	Solution
Évaluer le modèle sur les données d’entraînement	Performance surestimée	Toujours garder un jeu de test séparé
Fuite de données (data leakage)	Modèle excellent en test, inutile en réalité	Exclure les variables connues seulement après l’événement à prédire
Surapprentissage	Le modèle apprend par cœur le bruit	Modèle plus simple, régularisation, plus de données, validation croisée
Se fier à l’exactitude sur des classes déséquilibrées	Un modèle qui prédit toujours « non » semble bon	Suivre rappel, précision, F1 ou AUC
Normaliser avant la séparation train/test	Information du test qui fuit dans l’entraînement	Ajuster les transformations sur le seul jeu d’entraînement (pipelines scikit-learn)
Partir directement sur le deep learning	Complexité et coût inutiles	Commencer par une référence simple

La fuite de données est la plus sournoise : si votre fichier contient une colonne « date de résiliation », le modèle obtiendra un score parfait… en trichant. Demandez-vous toujours si chaque variable serait réellement disponible au moment de la prédiction.

Comment apprendre l’intelligence artificielle et le machine learning ?

Le machine learning se situe à la croisée de la programmation, des données et des statistiques. Voici le parcours que nous recommandons :

1. Les concepts (quelques heures) : IA, machine learning, deep learning, types d’apprentissage, rôle central des données.
2. Python et ses bibliothèques : les bases du langage, puis NumPy et Pandas. Si vous débutez, notre guide pour apprendre Python vous donne l’ordre de progression.
3. Le machine learning classique avec scikit-learn : régression, classification, évaluation, sur des jeux de données publics.
4. Le deep learning avec TensorFlow ou PyTorch : un premier réseau dense, puis un réseau convolutif sur des images.
5. Un projet personnel complet sur des données qui vous intéressent, de la question métier à l’évaluation. Savoir extraire vos données avec SQL est alors un atout.

Pour structurer cette progression, la formation vidéo sur le deep learning, le machine learning et l’IA d’EspritAcadémique propose trois heures trente de contenu, sans prérequis. Elle aborde notamment :

• les fondations de l’IA, son histoire et la façon dont un modèle apprend à partir des données ;
• la distinction entre IA, machine learning et deep learning, puis entre apprentissage supervisé et non supervisé ;
• l’anatomie des réseaux de neurones, leurs défis et leurs applications, ainsi que le traitement du langage naturel ;
• la manipulation de données en Python avec NumPy et Pandas ;
• les premiers pas avec TensorFlow et PyTorch ;
• la construction d’un pipeline d’IA complet, de bout en bout.

Si vous travaillez surtout dans des tableurs, notre guide sur l’intelligence artificielle dans Excel montre aussi comment tirer parti de l’IA sans coder.

En résumé

Le machine learning permet à un programme d’apprendre à partir d’exemples plutôt que de règles écrites à la main ; le deep learning en est la branche fondée sur les réseaux de neurones profonds. Un projet réussi suit toujours la même démarche : une question précise, des données soigneusement préparées, un jeu de test séparé, un modèle de référence simple et une métrique adaptée au métier. Commencez par Python, Pandas et scikit-learn, puis passez à PyTorch ou TensorFlow quand vos données le justifient.