Qu’est-ce que le Machine Learning ?

Le Machine Learning (apprentissage automatique) est une branche de l’intelligence artificielle qui permet aux ordinateurs d’apprendre à partir de données, sans être explicitement programmés. Au lieu de coder des règles « si le client a plus de 3 achats, alors c’est un client fidèle », vous donnez au ML des milliers d’exemples de clients fidèles et non fidèles, et il découvre les règles tout seul. Ce tutoriel explique les 3 types fondamentaux de ML avec des exemples concrets et du code Python.

Les 3 types de Machine Learning

1. Apprentissage supervisé

Vous donnez au modèle des données avec les « bonnes réponses » (labels). Il apprend la relation entre les entrées et les sorties. C’est comme un élève qui apprend avec un corrigé.

Exemples d'apprentissage supervisé :

CLASSIFICATION (prédire une catégorie) :
- Email → spam ou pas spam
- Photo → chat ou chien
- Transaction → frauduleuse ou légitime
- CV → embaucher ou ne pas embaucher

RÉGRESSION (prédire un nombre) :
- Surface + quartier + étage → prix d'un appartement à Dakar
- Historique de ventes → ventes du mois prochain
- Profil client → montant probable de la prochaine commande

Code Python — Classification de spam :
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer

# Données d'entraînement
emails = [
    "Gagnez 1 million FCFA maintenant", "Réunion demain à 10h",
    "Offre spéciale 90% de réduction", "Le rapport est prêt",
    "Cliquez ici pour votre cadeau gratuit", "Bien reçu, merci",
    "Crédit gratuit sans condition", "Le client a confirmé le rdv"
]
labels = [1, 0, 1, 0, 1, 0, 1, 0]  # 1=spam, 0=pas spam

# Transformer le texte en nombres
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(emails)

# Entraîner le modèle
model = MultinomialNB()
model.fit(X, labels)

# Tester sur un nouvel email
test = vectorizer.transform(["Offre exceptionnelle cliquez vite"])
print(f"Spam : {model.predict(test)[0] == 1}")  # True

2. Apprentissage non supervisé

Le modèle reçoit des données SANS labels. Il doit trouver des patterns et des groupes par lui-même. C’est comme trier un tas de vêtements sans qu’on vous dise les catégories — vous regroupez naturellement par couleur, type ou taille.

Exemples d'apprentissage non supervisé :

CLUSTERING (regroupement) :
- Segmenter vos clients en groupes (fidèles, occasionnels, à risque)
- Regrouper des articles similaires sur votre blog
- Identifier des zones géographiques de livraison optimales

Code Python — Segmentation clients :
from sklearn.cluster import KMeans
import pandas as pd

# Données clients
clients = pd.DataFrame({
    'nb_achats': [1, 2, 15, 20, 3, 18, 1, 25, 2, 12],
    'montant_total': [25000, 45000, 850000, 1200000, 60000, 
                      950000, 15000, 1500000, 35000, 720000],
    'jours_depuis_dernier_achat': [90, 60, 5, 2, 45, 8, 120, 1, 80, 10]
})

# K-Means avec 3 groupes
kmeans = KMeans(n_clusters=3, random_state=42)
clients['segment'] = kmeans.fit_predict(clients)

print(clients.groupby('segment').mean().round(0))
# Segment 0 : Clients fidèles (beaucoup d'achats, montants élevés, récents)
# Segment 1 : Clients occasionnels (peu d'achats, montants moyens)
# Segment 2 : Clients dormants (anciens, peu d'activité)

3. Apprentissage par renforcement

Le modèle apprend par essai-erreur en interagissant avec un environnement. Il reçoit des récompenses pour les bonnes actions et des pénalités pour les mauvaises. C’est comme apprendre à conduire : on apprend de ses erreurs. C’est le type de ML utilisé par les voitures autonomes, les robots et les IA de jeux (AlphaGo).

Le workflow complet d’un projet ML

Les 7 étapes d'un projet Machine Learning :

1. DÉFINIR LE PROBLÈME
   "Je veux prédire quels clients vont annuler leur abonnement"

2. COLLECTER LES DONNÉES
   Exporter les données depuis votre CRM, base de données, Excel
   Plus vous avez de données, meilleur sera le modèle

3. NETTOYER LES DONNÉES (60% du temps !)
   - Supprimer les doublons
   - Gérer les valeurs manquantes
   - Corriger les erreurs de saisie
   - Standardiser les formats

4. EXPLORER LES DONNÉES (EDA)
   Visualiser, calculer des statistiques, comprendre les distributions
   Identifier les corrélations entre les variables

5. ENTRAÎNER LE MODÈLE
   - Séparer données en train (80%) et test (20%)
   - Essayer plusieurs algorithmes
   - Ajuster les hyperparamètrès

6. ÉVALUER
   Mesurer la précision sur les données de test
   Si insatisfaisant : retour à l'étape 3, 4 ou 5

7. DÉPLOYER
   Intégrer le modèle dans votre application ou workflow

Choisir le bon algorithme

Pour la classification : commencez par Logistic Regression (simple et rapide), puis essayez Random Forest (meilleur en général) et Gradient Boosting/XGBoost (souvent le meilleur mais plus complexe).

Pour la régression : commencez par Linear Regression, puis essayez Random Forest Regressor et Gradient Boosting Regressor.

Pour le clustering : K-Means est le plus simple et couvre 80% des cas. DBSCAN est meilleur pour les groupes de formes irrégulières.

Règle d’or : commencez toujours par l’algorithme le plus simple. S’il donne des résultats satisfaisants (>85% de précision), inutile de complexifier. La simplicité facilite la maintenance et l’explication des résultats aux non-techniciens.

Étape 1 : Installer Python et l’environnement de travail

Téléchargez Python 3.12 sur python.org et lancez l’installateur en cochant Add Python to PATH. Sur un poste à Dakar comme à Abidjan, vérifiez l’installation en ouvrant un terminal et en tapant la commande python –version. La sortie attendue est Python 3.12.x. Si elle s’affiche, l’environnement est prêt.

python --version
python -m venv mlenv
mlenv\Scripts\activate
pip install scikit-learn pandas matplotlib jupyter

Le module venv crée un environnement isolé pour ne pas polluer le Python système. L’activation se fait avec le script Activate sur Windows, ou source mlenv/bin/activate sur Linux et macOS. Une fois activé, votre invite affiche (mlenv) en préfixe : c’est le signal que les paquets installés ne toucheront que ce projet.

Étape 2 : Comprendre supervisé vs non supervisé

Le machine learning supervisé apprend à partir d’exemples étiquetés : on lui donne des images de billets de 1000 FCFA et 5000 FCFA déjà classés, il apprend à distinguer les deux. Le non supervisé travaille sans étiquettes : il regroupe les clients d’une boutique de Sandaga en segments selon leurs habitudes d’achat sans qu’on lui dise quels segments existent.

En pratique, 80 pourcent des projets en entreprise sont du supervisé : prédire un défaut de paiement, classer un e-mail en spam, estimer le prix d’un appartement aux Almadies. Commencez par le supervisé, c’est plus facile à valider et à mesurer.

Étape 3 : Charger un jeu de données avec pandas

Lancez Jupyter avec la commande jupyter notebook. Dans une cellule, importez pandas et chargez le dataset Iris fourni par scikit-learn. C’est le Hello World du ML : 150 fleurs, 4 mesures, 3 espèces à reconnaître.

from sklearn.datasets import load_iris
import pandas as pd
data = load_iris()
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target
print(df.head())

La sortie affiche les 5 premières lignes avec longueur et largeur des sépales et pétales, plus une colonne target valant 0, 1 ou 2 selon l’espèce. Vérifiez avec df.shape : vous devez voir (150, 5). Si la sortie diffère, l’installation de scikit-learn a échoué : relancez pip install scikit-learn dans le bon environnement.

Étape 4 : Séparer entraînement et test

Ne jamais entraîner et évaluer sur les mêmes données. Le modèle mémoriserait par cœur sans réellement apprendre, comme un étudiant qui révise uniquement les annales sans comprendre. La fonction train_test_split coupe automatiquement le jeu en deux.

from sklearn.model_selection import train_test_split
X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)
print(len(X_train), len(X_test))

La sortie affiche 120 et 30. Le paramètre random_state=42 garantit que la séparation est reproductible : exécutez deux fois, vous obtenez la même découpe. C’est essentiel pour comparer plusieurs modèles équitablement.

Étape 5 : Entraîner un premier modèle de classification

Commencez par un k-Nearest Neighbors, l’un des modèles les plus intuitifs : il classe une nouvelle fleur selon les espèces des fleurs les plus proches dans l’espace des mesures. Trois lignes suffisent.

from sklearn.neighbors import KNeighborsClassifier
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

La méthode fit fait l’apprentissage. La méthode score renvoie l’accuracy sur le jeu de test, généralement entre 0,93 et 1,0 sur Iris. Plus la valeur est proche de 1, mieux c’est. Sur un dataset réel comme la prédiction de défaut sur prêt mobile money, attendez-vous plutôt à 0,75-0,85.

Étape 6 : Évaluer avec les bonnes métriques

L’accuracy seule peut tromper. Si 95 pourcent de vos clients ne font pas défaut, un modèle qui prédit toujours non rembourse aura 95 pourcent d’accuracy mais sera inutile. Utilisez precision, recall et F1-score, fournis par classification_report.

from sklearn.metrics import classification_report
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

La sortie tabulaire montre pour chaque classe la précision (parmi les prédits positifs, combien le sont vraiment), le rappel (parmi les vrais positifs, combien sont retrouvés) et le F1 qui synthétise les deux. Visez un F1 supérieur à 0,80 pour un modèle exploitable en production.

Étape 7 : Passer à la régression

Quand la cible est un nombre continu et non une catégorie (prix d’un loyer au Plateau, nombre de visites attendues), utilisez la régression. Le modèle de base est LinearRegression. La métrique change : mean_squared_error et R2.

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
reg = LinearRegression().fit(X_train, y_train)
preds = reg.predict(X_test)
print(mean_squared_error(y_test, preds), r2_score(y_test, preds))

Un R2 proche de 1 signifie que le modèle explique presque toute la variance. Un R2 négatif signifie qu’il fait pire qu’une constante : c’est un signal d’alarme, vos features ne sont pas pertinentes ou il faut les transformer (logarithme, normalisation).

Étape 8 : Aller plus loin avec un projet concret

Téléchargez un dataset Kaggle adapté au contexte ouest-africain comme les transactions Mixx by Yas anonymisées (cherchez mobile money dataset sur Kaggle). Appliquez les sept étapes : chargement, exploration, séparation, entraînement, évaluation. Itérez en changeant le modèle (RandomForestClassifier, GradientBoostingClassifier) et observez l’impact sur le F1. À lire ensuite, consultez notre guide Python pour le ML et notre tutoriel réseaux de neurones.

Étape 9 : Préparer les données réelles avec pandas

Les datasets pédagogiques comme Iris sont propres. Les vrais sont sales : valeurs manquantes, doublons, dates en texte, devises mélangées. Avant de modéliser, nettoyez. Lisez votre fichier CSV avec pd.read_csv puis inspectez avec df.info() qui révèle le type de chaque colonne et le nombre de cellules non nulles. Une colonne montant à 8 000 valeurs sur 10 000 attend un traitement.

df = pd.read_csv('transactions.csv')
df.info()
df['montant_fcfa'] = df['montant_fcfa'].fillna(df['montant_fcfa'].median())
df = df.drop_duplicates()

Remplacer les valeurs manquantes par la médiane est plus robuste que la moyenne car la médiane résiste aux valeurs extrêmes. Pour une variable catégorielle comme le type d’opération, remplissez avec la modalité la plus fréquente via df[‘type’].fillna(df[‘type’].mode()[0]).

Étape 10 : Encoder les variables catégorielles

Les modèles scikit-learn ne mangent que des nombres. Une colonne ville contenant Dakar, Abidjan, Bamako doit être transformée. Pour les variables sans ordre, utilisez pd.get_dummies qui crée une colonne binaire par modalité. Pour celles avec ordre (faible, moyen, élevé), utilisez OrdinalEncoder qui assigne 0, 1, 2.

df_enc = pd.get_dummies(df, columns=['ville', 'type_operation'])
print(df_enc.head())

Vérifiez que df_enc.shape compte plus de colonnes qu’avant : c’est le signe que l’encodage a fonctionné. Évitez d’encoder une colonne avec 1 000 modalités (par exemple un identifiant client) : vous exploseriez la dimensionnalité et nuiriez aux performances.

Étape 11 : Normaliser les échelles

Les algorithmes basés sur la distance (k-NN, SVM, k-means) sont sensibles aux échelles. Une colonne montant en FCFA varie de 0 à 1 000 000, une colonne âge varie de 18 à 80. Sans normalisation, le montant écrase l’âge. StandardScaler centre et réduit chaque colonne à moyenne 0 et écart-type 1.

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train_sc = scaler.fit_transform(X_train)
X_test_sc = scaler.transform(X_test)

Notez la dissymétrie : on appelle fit_transform sur le train et seulement transform sur le test. Sinon, vous laissez fuiter de l’information du test vers le train et vos métriques deviennent optimistes. Cette discipline du data leakage est le réflexe à acquérir en priorité.

Étape 12 : Sauvegarder et déployer le modèle

Une fois satisfait, persistez le modèle avec joblib. Le fichier .pkl peut ensuite être chargé dans une API Flask ou FastAPI servant les prédictions en temps réel à votre application mobile, par exemple une app de scoring crédit utilisée par les agents Mixx by Yas en agence à Abidjan ou Bamako.

import joblib
joblib.dump(model, 'modele_credit.pkl')
modele = joblib.load('modele_credit.pkl')
print(modele.predict([[35, 250000, 2]]))

Le modèle reste portable d’une machine à l’autre tant que la version de scikit-learn est compatible. En production, fixez la version dans requirements.txt avec scikit-learn==1.5.2 pour éviter qu’une mise à jour ne casse votre pipeline.

Étape 13 : Surveiller le modèle après mise en production

Un modèle qui marchait en janvier peut dériver en mars : les comportements clients évoluent, les prix changent, de nouveaux fournisseurs apparaissent à Sandaga ou Yopougon. Mettez en place une routine mensuelle qui réévalue le modèle sur les transactions du mois écoulé et alerte par e-mail si l’accuracy chute de plus de 5 points. Cette pratique, appelée monitoring, transforme votre projet ML d’expérience ponctuelle en système vivant. Un script Python planifié via le Planificateur de tâches Windows ou cron sur Linux suffit pour démarrer.