C'est quoi le Machine Learning ?
Mise à jour :
Vous entendez parler de Machine Learning partout, mais vous ne savez pas par où commencer ? Ce guide est conçu spécialement pour vous. Nous allons démystifier l’apprentissage automatique et vous guider pas à pas, de zéro à votre premier projet fonctionnel.
Qu’est-ce que le Machine Learning concrètement ?
Le Machine Learning (apprentissage automatique en français) est une branche de l’intelligence artificielle qui permet aux ordinateurs d’apprendre à partir de données sans être explicitement programmés pour chaque tâche.
Imaginez que vous voulez créer un programme qui reconnaît des chats sur des photos. En programmation classique, vous devriez écrire manuellement toutes les règles : “un chat a des oreilles pointues”, “un chat a des moustaches”, etc. Avec le Machine Learning, vous montrez simplement au programme des milliers de photos de chats, et il apprend tout seul à les reconnaître.
Comment ça fonctionne concrètement ?
Le processus ressemble à celui d’un enfant qui apprend :
- Observation : Le système reçoit des données (images, textes, chiffres)
- Apprentissage : Il identifie des patterns et des tendances
- Prédiction : Il applique ce qu’il a appris sur de nouvelles données
- Amélioration : Il s’ajuste en fonction des erreurs
C’est exactement ce qui se passe quand Netflix vous recommande des films ou quand votre boîte mail détecte automatiquement les spams.
Prérequis pour démarrer en Machine Learning
Bonne nouvelle : vous n’avez pas besoin d’être un expert pour commencer. Voici ce dont vous avez besoin.
Connaissances essentielles
Mathématiques de base :
- Algèbre : comprendre les équations simples et les variables
- Statistiques : moyennes, écarts-types, probabilités
- Géométrie : comprendre les distances et les espaces
Ne paniquez pas ! Un niveau lycée suffit pour débuter. Vous approfondirez au fur et à mesure.
Programmation :
- Python est le langage de référence en Machine Learning
- Connaissance des bases : variables, boucles, fonctions
- Pas besoin d’être un développeur senior
Outils et environnement de travail
Configuration minimale :
- Un ordinateur avec 8 Go de RAM minimum
- Python 3.8 ou supérieur installé
- Un éditeur de code (VS Code, PyCharm, Jupyter Notebook)
Bibliothèques Python incontournables :
- NumPy : calculs numériques
- Pandas : manipulation de données
- Scikit-learn : algorithmes de Machine Learning
- Matplotlib : visualisation de données
Nous verrons comment les installer dans la section suivante.
Glossaire des termes techniques
Avant de plonger plus profondément, voici un glossaire des termes techniques couramment utilisés en Machine Learning.
💡 Conseil : Gardez ce glossaire à portée de main pendant votre apprentissage. La maîtrise du vocabulaire technique est essentielle pour progresser en Machine Learning et communiquer efficacement avec d’autres praticiens.
- Accuracy (Précision) : Métrique qui mesure le pourcentage de prédictions correctes par rapport au nombre total de prédictions. Formule : (Vrais Positifs + Vrais Négatifs) / Total des prédictions.
- Algorithm (Algorithme) : Ensemble d’instructions mathématiques et logiques permettant à un ordinateur de résoudre un problème ou d’apprendre à partir de données.
- Artificial Intelligence (AI) (Intelligence Artificielle - IA) : Domaine informatique visant à créer des systèmes capables d’effectuer des tâches nécessitant normalement l’intelligence humaine.
- Bias (Biais) : Erreur systématique dans un modèle qui l’empêche d’apprendre correctement les relations dans les données. Peut provenir des données ou de l’algorithme lui-même.
- Binary Classification (Classification Binaire) : Type de problème de Machine Learning où l’objectif est de prédire l’appartenance à l’une de deux classes possibles (exemple : spam/non-spam.
- Classification : Type d’apprentissage supervisé où l’objectif est de prédire une catégorie ou classe discrète à partir des caractéristiques d’entrée.
- Clustering : Technique d’apprentissage non supervisé qui groupe automatiquement des données similaires sans étiquettes prédéfinies.
- Cross-Validation (Validation Croisée) : Technique d’évaluation qui divise les données en plusieurs sous-ensembles pour tester la robustesse d’un modèle.
- Dataset (Jeu de données) : Collection structurée de données utilisée pour entraîner, valider ou tester un modèle de Machine Learning.
- Deep Learning (Apprentissage Profond) : Sous-domaine du Machine Learning utilisant des réseaux de neurones artificiels avec plusieurs couches cachées.
- Decision Tree (Arbre de Décision) : Algorithme qui crée un modèle de prédiction sous forme d’arbre où chaque nœud représente un test sur une caractéristique.
- Epoch (Époque) : Un passage complet de l’algorithme d’apprentissage sur l’ensemble des données d’entraînement.
- Evaluation Metrics (Métriques d’Évaluation) : Mesures quantitatives utilisées pour évaluer les performances d’un modèle (accuracy, precision, recall, etc.).
- Feature (Caractéristique/Variable) : Variable d’entrée individuelle utilisée par un algorithme pour faire des prédictions. Aussi appelée “attribut” ou “dimension”.
- Feature Engineering (Ingénierie des Caractéristiques) : Processus de sélection, modification ou création de nouvelles features à partir des données brutes.
- F1-Score : Métrique combinant precision et recall en une seule valeur. Moyenne harmonique de la precision et du recall.
- Gradient Descent (Descente de Gradient) : Algorithme d’optimisation utilisé pour minimiser la fonction de coût en ajustant itérativement les paramètres du modèle.
- Generalization (Généralisation) : Capacité d’un modèle à bien performer sur de nouvelles données non vues pendant l’entraînement.
- Hyperparameter (Hyperparamètre) : Paramètre de configuration d’un algorithme qui doit être défini avant l’entraînement (exemple : nombre d’arbres dans une Random Forest).
- K-Means : Algorithme de clustering qui partitionne les données en K groupes en minimisant la variance intra-cluster.
- K-Nearest Neighbors (KNN) (K Plus Proches Voisins) : Algorithme qui classe un point en fonction de la classe majoritaire de ses K voisins les plus proches.
- Label (Étiquette) : Variable cible ou sortie désirée dans l’apprentissage supervisé. Ce que le modèle essaie de prédire.
- Linear Regression (Régression Linéaire) : Algorithme qui modélise la relation entre une variable dépendante et des variables indépendantes par une équation linéaire.
- Logistic Regression (Régression Logistique) : Algorithme de classification qui utilise la fonction logistique pour modéliser la probabilité d’appartenance à une classe.
- Machine Learning (ML) (Apprentissage Automatique) : Branche de l’IA permettant aux ordinateurs d’apprendre à partir de données sans être explicitement programmés.
- Model (Modèle) : Représentation mathématique d’un processus du monde réel, créée par un algorithme d’apprentissage à partir de données d’entraînement.
- Multiclass Classification (Classification Multiclasse) : Problème de classification avec plus de deux classes possibles.
- Neural Network (Réseau de Neurones) : Modèle inspiré du cerveau humain, composé de neurones artificiels connectés en couches.
- Normalization (Normalisation) : Technique de préparation des données qui ajuste les valeurs à une échelle commune, généralement entre 0 et 1.
- Outlier (Valeur Aberrante) : Point de donnée qui diffère significativement des autres observations et peut affecter négativement les performances du modèle.
- Overfitting (Surapprentissage) : Phénomène où un modèle apprend trop spécifiquement les données d’entraînement et perd sa capacité de généralisation.
- Parameter (Paramètre) : Variable interne du modèle ajustée automatiquement pendant l’entraînement (exemple : poids dans un réseau de neurones).
- Precision (Précision) : Métrique qui mesure la proportion de prédictions positives correctes parmi toutes les prédictions positives.
- Prediction (Prédiction) : Sortie d’un modèle pour une nouvelle donnée d’entrée non vue pendant l’entraînement.
- Random Forest (Forêt Aléatoire) : Algorithme d’ensemble qui combine plusieurs arbres de décision pour améliorer les performances et réduire l’overfitting.
- Recall (Rappel/Sensibilité) : Métrique qui mesure la proportion de vrais positifs correctement identifiés parmi tous les vrais positifs.
- Regression (Régression) : Type d’apprentissage supervisé où l’objectif est de prédire une valeur numérique continue.
- Reinforcement Learning (Apprentissage par Renforcement) : Type d’apprentissage où un agent apprend à prendre des décisions en recevant des récompenses ou pénalités.
- Supervised Learning (Apprentissage Supervisé) : Type d’apprentissage utilisant des données étiquetées pour entraîner un modèle à faire des prédictions.
- Support Vector Machine (SVM) : Algorithme qui trouve la frontière optimale (hyperplan) pour séparer différentes classes de données.
- Standardization (Standardisation) : Technique de normalisation qui centre les données autour de zéro avec un écart-type de 1.
- Target (Cible) : Variable que le modèle essaie de prédire. Synonyme de “label” ou “variable dépendante”.
- Test Set (Ensemble de Test) : Portion des données réservée pour évaluer les performances finales du modèle, jamais utilisée pendant l’entraînement.
- Training (Entraînement) : Processus d’ajustement des paramètres d’un modèle à partir des données d’entraînement.
- Training Set (Ensemble d’Entraînement) : Portion des données utilisée pour entraîner le modèle et ajuster ses paramètres.
- Underfitting (Sous-apprentissage) : Phénomène où un modèle est trop simple pour capturer les relations complexes dans les données.
- Unsupervised Learning (Apprentissage Non Supervisé) : Type d’apprentissage utilisant des données non étiquetées pour découvrir des structures cachées.
- Validation Set (Ensemble de Validation) : Portion des données utilisée pour évaluer et ajuster les hyperparamètres pendant le développement du modèle.
- Variance : Mesure de la sensibilité d’un modèle aux petites variations dans les données d’entraînement.
Les types d’apprentissage automatique
Le Machine Learning se divise en trois grandes familles selon la manière dont l’algorithme apprend.
Apprentissage supervisé
Dans l’apprentissage supervisé, vous fournissez à l’algorithme des données déjà étiquetées. C’est comme un professeur qui corrige les devoirs d’un élève.
Exemple concret : Vous voulez prédire le prix d’une maison. Vous donnez à l’algorithme :
- Des données historiques (surface, nombre de pièces, quartier)
- Les prix réels correspondants
L’algorithme apprend la relation entre les caractéristiques et les prix, puis peut prédire le prix de nouvelles maisons.
Cas d’usage courants :
- Détection de spam dans les emails
- Diagnostic médical assisté
- Prévision de ventes
- Reconnaissance faciale
Apprentissage non supervisé
Dans l’apprentissage non supervisé, l’algorithme explore des données sans étiquettes et trouve lui-même des structures cachées.
Exemple concret : Vous avez une base de données clients. L’algorithme va automatiquement regrouper les clients ayant des comportements similaires (segmentation), sans que vous lui disiez comment faire.
Cas d’usage courants :
- Segmentation client pour le marketing
- Détection d’anomalies bancaires
- Systèmes de recommandation
- Compression de données
Apprentissage par renforcement
L’apprentissage par renforcement fonctionne comme le dressage d’un animal : l’algorithme reçoit des récompenses quand il fait bien et des pénalités quand il se trompe.
Exemple concret : Un robot qui apprend à marcher. Il essaie différents mouvements, tombe, se relève, et petit à petit comprend quelle séquence de mouvements fonctionne le mieux.
Cas d’usage courants :
- Robots autonomes
- Jeux vidéo (AlphaGo de Google)
- Véhicules autonomes
- Trading algorithmique
Installation de votre environnement Python
La mise en place d’un environnement Python optimal est indispensable pour débuter sereinement en Machine Learning. Cette section vous guide pas à pas pour éviter les erreurs courantes de configuration.
Étape 1 : Installer Python
Python est le langage de programmation le plus utilisé en Machine Learning grâce à sa simplicité et à son écosystème riche en bibliothèques spécialisées.
Sur Windows :
- Téléchargement : Rendez-vous sur python.org ↗ et téléchargez la dernière version stable (3.9 ou supérieure recommandée)
- Installation : Lancez l’installateur et cochez impérativement “Add Python to PATH”. Cette option permet d’utiliser Python depuis n’importe quel terminal
- Vérification : Ouvrez l’invite de commande (cmd) et tapez :
# Vérifier l'installation de Pythonpython --version# Devrait afficher : Python 3.x.x
# Vérifier que pip est installé (gestionnaire de paquets)pip --version
⚠️ Problème courant : Si la commande
python
n’est pas reconnue, l’option “Add Python to PATH” n’a pas été cochée. Réinstallez Python en cochant cette option.
Sur Linux/Mac :
La plupart des distributions Linux et macOS incluent Python par défaut, mais souvent dans une version ancienne.
# Vérifier la version installéepython3 --version
# Si la version est inférieure à 3.8, installer une version récente# Ubuntu/Debian (recommandé pour les débutants)sudo apt update && sudo apt install python3 python3-pip python3-venv
# macOS avec Homebrew (installer d'abord Homebrew si nécessaire)brew install python3
# Vérifier que tout fonctionnepython3 --version && pip3 --version
Étape 2 : Créer un environnement virtuel
Les environnements virtuels sont essentiels en Machine Learning. Ils créent un espace isolé pour chaque projet, évitant les conflits entre différentes versions de bibliothèques.
Pourquoi utiliser un environnement virtuel ?
- Isolation : Chaque projet a ses propres versions de bibliothèques
- Reproductibilité : Vous pouvez recréer exactement le même environnement
- Propreté : Pas de pollution de votre Python système
- Collaboration : Facilite le partage de projets avec d’autres développeurs
Création et activation :
# Naviguer vers votre dossier de travailcd ~/MachineLearning # Créez ce dossier si nécessaire
# Créer un environnement virtuel nommé "ml_env"python3 -m venv ml_env
# Activer l'environnement# Sur Linux/Macsource ml_env/bin/activate
# Sur Windowsml_env\Scripts\activate
# ✅ Succès : votre terminal affiche maintenant (ml_env) au début de chaque ligne# Exemple : (ml_env) user@computer:~/Documents/MachineLearning$
Commandes utiles pour gérer les environnements :
# Désactiver l'environnement actueldeactivate
# Réactiver plus tard (depuis le dossier contenant ml_env)source ml_env/bin/activate # Linux/Mac# ouml_env\Scripts\activate # Windows
# Voir les paquets installés dans cet environnementpip list
🎯 Bonnes pratiques : Créez toujours un nouvel environnement virtuel pour chaque projet ML. Nommez-le de manière descriptive (ex:
ml_spam_detection
,ml_house_prices
).
Étape 3 : Installer les bibliothèques essentielles
Maintenant que votre environnement virtuel est activé, installons les bibliothèques Python indispensables pour le Machine Learning. Chaque bibliothèque a un rôle spécifique.
Installation étape par étape :
# 1. Mettre à jour pip (gestionnaire de paquets Python)pip install --upgrade pip# pip est l'outil qui installe les bibliothèques Python
# 2. Installer les bibliothèques de manipulation de donnéespip install numpy pandas# numpy : calculs numériques rapides (matrices, vecteurs)# pandas : manipulation de données tabulaires (comme Excel en Python)
# 3. Installer les bibliothèques de visualisationpip install matplotlib seaborn# matplotlib : graphiques de base (courbes, histogrammes)# seaborn : graphiques statistiques avancés et esthétiques
# 4. Installer scikit-learn pour le Machine Learningpip install scikit-learn# La bibliothèque principale avec tous les algorithmes ML
# 5. Installer Jupyter Notebook pour un environnement interactifpip install jupyter# Interface web pour coder de manière interactive
# 6. Vérifier toutes les installationspip list
Comprendre le rôle de chaque bibliothèque :
- NumPy : Foundation de tout le calcul scientifique en Python. Permet de manipuler des tableaux multidimensionnels efficacement
- Pandas : Excel version programmation. Permet de charger, nettoyer et transformer des données
- Matplotlib : Création de graphiques. Essentiel pour visualiser vos données et résultats
- Seaborn : Couche au-dessus de matplotlib pour des graphiques plus beaux et plus statistiques
- Scikit-learn : Contient tous les algorithmes ML (régression, classification, clustering)
- Jupyter : Interface web interactive pour expérimenter et documenter votre code
Installation alternative avec un seul fichier :
Vous pouvez créer un fichier requirements.txt
avec ce contenu :
numpy>=1.21.0pandas>=1.3.0matplotlib>=3.4.0seaborn>=0.11.0scikit-learn>=1.0.0jupyter>=1.0.0
Puis installer tout d’un coup :
pip install -r requirements.txt
⏱️ Temps d’installation : Comptez 5-10 minutes selon votre connexion internet. Les bibliothèques ML sont volumineuses car elles incluent des optimisations mathématiques complexes.
Étape 4 : Tester votre installation
Cette étape vérifie que toutes les bibliothèques fonctionnent correctement ensemble. Nous allons créer un petit programme qui utilise chaque bibliothèque installée.
Test complet d’installation :
Créez un nouveau fichier nommé test_install.py
dans votre dossier de travail
et copiez ce code commenté :
# Test d'installation des bibliothèques Machine Learningprint("🔍 Test des importations...")
try: import numpy as np print("✅ NumPy importé avec succès")except ImportError as e: print(f"❌ Erreur NumPy : {e}")
try: import pandas as pd print("✅ Pandas importé avec succès")except ImportError as e: print(f"❌ Erreur Pandas : {e}")
try: import matplotlib.pyplot as plt print("✅ Matplotlib importé avec succès")except ImportError as e: print(f"❌ Erreur Matplotlib : {e}")
try: from sklearn import datasets print("✅ Scikit-learn importé avec succès")except ImportError as e: print(f"❌ Erreur Scikit-learn : {e}")
print("\n🧪 Test pratique avec le dataset Iris...")
# Charger le jeu de données Iris (classique en ML)iris = datasets.load_iris()
# Afficher des informations sur le datasetprint(f"📊 Jeu de données Iris chargé :")print(f" - {iris.data.shape[0]} exemples (fleurs)")print(f" - {iris.data.shape[1]} caractéristiques par fleur")print(f" - Caractéristiques : {iris.feature_names}")print(f" - Classes de fleurs : {iris.target_names}")
# Créer un DataFrame pandas pour une visualisation clairedf = pd.DataFrame(iris.data, columns=iris.feature_names)df['species'] = iris.target_names[iris.target]
print(f"\n📋 Aperçu des données :")print(df.head())
# Créer un graphique de testprint(f"\n📈 Création d'un graphique de test...")plt.figure(figsize=(10, 6))plt.scatter(iris.data[:, 0], iris.data[:, 1], c=iris.target, cmap='viridis')plt.xlabel(iris.feature_names[0])plt.ylabel(iris.feature_names[1])plt.title("Test d'installation réussi - Dataset Iris")plt.colorbar(label='Espèce de fleur')
# Tenter d'afficher le graphique (gérer les environnements sans interface graphique)try: plt.show() print("📊 Graphique affiché avec succès !")except Exception as e: print(f"⚠️ Affichage graphique non disponible : {e}") print("💡 Conseil : Utilisez Jupyter Notebook pour voir los graphiques") # Sauvegarder le graphique comme alternative plt.savefig('test_installation.png', dpi=150, bbox_inches='tight') print("📁 Graphique sauvegardé sous 'test_installation.png'")
plt.close() # Fermer la figure pour libérer la mémoire
print("✅ Installation validée ! Votre environnement est prêt pour le Machine Learning.")print("🚀 Vous pouvez maintenant commencer vos projets ML !")
Exécution du test :
# Assurez-vous que votre environnement virtuel est activé# Vous devez voir (ml_env) au début de votre prompt
python test_install.py
Interprétation des résultats :
- ✅ Succès complet : Une fenêtre graphique s’ouvre avec un nuage de points coloré, et tous les messages de succès s’affichent
- ✅ Import réussi + graphique sauvegardé : Les bibliothèques fonctionnent, le graphique est sauvegardé comme fichier PNG
- ⚠️ Import réussi mais affichage impossible : Bibliothèques installées mais environnement sans interface graphique (serveur, SSH, etc.)
- ❌ Erreurs d’import : Réinstallez les bibliothèques manquantes avec
pip install nom_bibliotheque
🎉 Félicitations ! Si tous les tests passent, vous avez un environnement Machine Learning complètement fonctionnel. Vous êtes prêt à aborder les concepts théoriques et pratiques !
Comprendre les données : la base du Machine Learning
Avant de créer des modèles, il faut comprendre vos données. C’est l’étape la plus importante.
Qu’est-ce qu’un jeu de données ?
Un jeu de données (dataset) est un ensemble structuré d’informations organisées généralement sous forme de tableau :
- Chaque ligne représente un exemple (observation, échantillon)
- Chaque colonne représente une caractéristique (feature, variable)
Exemple : Prédiction du prix de maisons
Surface (m²) | Chambres | Jardin | Prix (€) |
---|---|---|---|
80 | 2 | Non | 200000 |
120 | 3 | Oui | 350000 |
65 | 1 | Non | 180000 |
- Features : Surface, Chambres, Jardin
- Target (cible) : Prix
- Observations : 3 maisons
Types de données
Données numériques :
- Continues : peuvent prendre n’importe quelle valeur (prix, température, poids)
- Discrètes : valeurs entières (nombre de chambres, âge en années)
Données catégorielles :
- Nominales : catégories sans ordre (couleur, ville, type)
- Ordinales : catégories avec ordre (petit/moyen/grand, note sur 5)
Nettoyer et préparer les données
Les données réelles sont rarement parfaites. Voici les problèmes courants et leurs solutions.
Valeurs manquantes :
import pandas as pdimport numpy as np
# Créer un exemple avec des valeurs manquantesdata = pd.DataFrame({ 'surface': [80, 120, np.nan, 95], 'prix': [200000, 350000, 280000, np.nan]})
# Identifier les valeurs manquantesprint(data.isnull().sum())
# Solution 1 : Supprimer les lignes avec valeurs manquantesdata_clean = data.dropna()
# Solution 2 : Remplacer par la moyennedata['surface'].fillna(data['surface'].mean(), inplace=True)
# Solution 3 : Remplacer par la médiane (plus robuste aux valeurs extrêmes)data['prix'].fillna(data['prix'].median(), inplace=True)
print(data)
Valeurs aberrantes (outliers) :
# Visualiser les outliers avec un boxplotimport matplotlib.pyplot as pltimport numpy as np
# Configuration pour éviter l'avertissement sur l'affichageplt.ioff() # Mode non-interactif
data = [20, 22, 25, 23, 24, 28, 200] # 200 est un outlier
plt.boxplot(data)plt.ylabel("Valeurs")plt.title("Détection d'outliers")plt.savefig("outliers_boxplot.png") # Sauvegarde au lieu d'affichageprint("Boxplot sauvegardé sous 'outliers_boxplot.png'")
# Filtrer les outliers avec l'écart interquartile (IQR)Q1 = np.percentile(data, 25)Q3 = np.percentile(data, 75)IQR = Q3 - Q1
# Définir les limites acceptableslower_bound = Q1 - 1.5 * IQRupper_bound = Q3 + 1.5 * IQR
# Filtrer les donnéesdata_filtered = [x for x in data if lower_bound <= x <= upper_bound]print(f"Données filtrées : {data_filtered}")
Normalisation des données :
Certains algorithmes fonctionnent mieux quand toutes les features sont à la même échelle.
from sklearn.preprocessing import StandardScaler, MinMaxScalerimport numpy as np
# Exemple de donnéesdata = np.array([[1, 200], [2, 300], [3, 400]])
# Méthode 1 : Standardisation (moyenne=0, écart-type=1)scaler_std = StandardScaler()data_standardized = scaler_std.fit_transform(data)print("Standardisé :\n", data_standardized)
# Méthode 2 : Normalisation Min-Max (ramène entre 0 et 1)scaler_minmax = MinMaxScaler()data_normalized = scaler_minmax.fit_transform(data)print("Normalisé :\n", data_normalized)
Votre premier modèle de Machine Learning
Il est temps de créer votre premier modèle ! Nous allons prédire si un email est un spam ou non.
Le problème : classification binaire
Nous avons des emails avec deux caractéristiques simples :
- Nombre de mots suspects (gratuit, argent, gagnant, etc.)
- Nombre de points d’exclamation
Et une étiquette : Spam (1) ou Ham/Normal (0)
Étape 1 : Préparer les données avec de vrais exemples d’emails
Ce que vous allez faire dans cette étape :
- Créer une liste d’emails (spams et emails normaux)
- Transformer le texte en nombres que l’ordinateur peut comprendre
- Voir concrètement comment passer du texte à des caractéristiques numériques
Action pratique : Copiez et exécutez ce code dans votre environnement Python :
import numpy as npimport pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import accuracy_score, confusion_matriximport re
# ÉTAPE 1A : Créer notre base de données d'emailsprint("🎯 ÉTAPE 1A : Construction de notre dataset d'emails")print("="*60)
# Créer un dataset d'emails réalistes avec leur contenuemails_data = [ # SPAMS - Messages suspects { "content": "FÉLICITATIONS !!! Vous avez gagné 1000€ ! Cliquez maintenant pour récupérer votre prix GRATUIT !!!", "is_spam": 1 }, { "content": "URGENT ! Votre compte sera suspendu ! Confirmez immédiatement vos informations bancaires ici : www.faux-site.com", "is_spam": 1 }, { "content": "Offre limitée ! Perdez 10kg en 5 jours GARANTI ! Pilules minceur GRATUITES ! Commandez maintenant !!!", "is_spam": 1 }, { "content": "ARGENT FACILE ! Gagnez 500€ par jour en travaillant 2h ! Aucune expérience requise ! Inscrivez-vous MAINTENANT !", "is_spam": 1 }, { "content": "Remboursement d'impôts ! Récupérez 1200€ immédiatement ! Cliquez pour vérifier vos informations fiscales !", "is_spam": 1 },
# EMAILS NORMAUX (HAM) - Messages légitimes { "content": "Bonjour, j'espère que vous allez bien. Pouvons-nous programmer une réunion pour discuter du projet ?", "is_spam": 0 }, { "content": "Votre commande Amazon a été expédiée. Numéro de suivi : 1234567890. Livraison prévue demain.", "is_spam": 0 }, { "content": "Rappel : rendez-vous chez le dentiste demain à 14h30. Merci de confirmer votre présence.", "is_spam": 0 }, { "content": "Salut ! Comment s'est passé ton weekend ? On se voit toujours jeudi pour le cinéma ?", "is_spam": 0 }, { "content": "Facture électricité du mois de mars : 85.50€. Échéance le 15 avril. Paiement par prélèvement automatique.", "is_spam": 0 }, { "content": "Newsletter mensuelle : découvrez nos nouveaux articles sur le développement web et les dernières tendances tech.", "is_spam": 0 }, { "content": "Confirmation de votre réservation à l'hôtel Grand Palace pour le 20 mai. Chambre double, 2 nuits.", "is_spam": 0 }]
# Convertir en DataFrame pandas (tableau structuré) pour une manipulation plus faciledf = pd.DataFrame(emails_data)
print("📧 Voici les emails de notre dataset :")print("="*50)for i, row in df.iterrows(): status = "🚨 SPAM" if row['is_spam'] == 1 else "✅ NORMAL" print(f"{status}: {row['content'][:80]}...") print()
print(f"📊 Total : {len(df)} emails ({df['is_spam'].sum()} spams, {len(df)-df['is_spam'].sum()} normaux)")print()
# ÉTAPE 1B : Transformer le texte en caractéristiques numériquesprint("🔄 ÉTAPE 1B : Transformation du texte en nombres")print("="*60)print("Le Machine Learning ne comprend que les nombres, pas le texte.")print("On va donc extraire des caractéristiques numériques de chaque email.")
# Fonction pour extraire des caractéristiques des emailsdef extract_features(email_content): """Extrait des caractéristiques numériques d'un email"""
# Mots suspects couramment utilisés dans les spams spam_words = [ 'gratuit', 'urgent', 'félicitations', 'gagné', 'argent', 'cliquez', 'maintenant', 'offre', 'limitée', 'garanti', 'immédiatement', 'facile', 'remboursement', 'promo' ]
email_lower = email_content.lower()
# Feature 1 : Nombre de mots suspects suspect_word_count = sum(1 for word in spam_words if word in email_lower)
# Feature 2 : Nombre de points d'exclamation exclamation_count = email_content.count('!')
# Feature 3 : Nombre de MAJUSCULES (mots en caps) caps_words = len([word for word in email_content.split() if word.isupper() and len(word) > 2])
# Feature 4 : Longueur de l'email email_length = len(email_content)
# Feature 5 : Présence d'URLs (indicateur simple) has_url = 1 if 'http' in email_lower or 'www.' in email_lower else 0
return [suspect_word_count, exclamation_count, caps_words, email_length, has_url]
# ÉTAPE 1C : Application de l'extraction sur tous nos emailsprint("\n🔍 ÉTAPE 1C : Extraction des caractéristiques pour tous les emails")print("="*60)
features = [] # Ici on va stocker les caractéristiques numériquestargets = [] # Ici on va stocker les réponses (0=normal, 1=spam)
print("Traitement de chaque email...")for i, row in df.iterrows(): email_content = row['content'] email_features = extract_features(email_content)
# Afficher le détail pour les 3 premiers emails (pour comprendre) if i < 3: spam_status = "SPAM" if row['is_spam'] == 1 else "NORMAL" print(f"\nEmail {i+1} ({spam_status}):") print(f" Texte: '{email_content[:60]}...'") print(f" Features extraites: {email_features}")
features.append(email_features) targets.append(row['is_spam'])
print(f"\n✅ Extraction terminée pour {len(features)} emails")
# Convertir en arrays NumPy (format requis par scikit-learn)X = np.array(features) # X = nos caractéristiques (features)y = np.array(targets) # y = nos réponses (ce qu'on veut prédire)
# Noms des caractéristiques pour la lisibilitéfeature_names = ['Mots suspects', 'Points d\'exclamation', 'Mots en CAPS', 'Longueur email', 'Contient URL']
print(f"\n📊 RÉSULTAT FINAL DE L'ÉTAPE 1 :")print(f"Features : {feature_names}")print(f"Matrice X (caractéristiques) :\n{X}")print(f"Vecteur y (réponses) : {y}")
# Créer un DataFrame pour une visualisation plus clairefeatures_df = pd.DataFrame(X, columns=feature_names)features_df['Est_Spam'] = yfeatures_df['Type'] = features_df['Est_Spam'].map({0: 'Email Normal', 1: 'Spam'})
print(f"\n📋 Tableau récapitulatif (plus lisible) :")print(features_df)
print(f"\n🎯 ÉTAPE 1 TERMINÉE !")print(f"Nous avons transformé {len(df)} emails en {len(feature_names)} caractéristiques numériques.")print(f"Maintenant l'ordinateur peut 'comprendre' nos emails !")
Étape 2 : Diviser nos données en deux groupes
Pourquoi cette étape ? Imaginez que vous apprenez les maths. Vous ne passez pas l’examen avec les mêmes exercices que vous avez utilisés pour apprendre ! C’est pareil ici : on va séparer nos emails en deux groupes :
- Groupe d’entraînement : Pour apprendre au modèle
- Groupe de test : Pour vérifier si le modèle a bien appris (avec des emails qu’il n’a jamais vus)
Action pratique : Continuez avec ce code après l’étape 1 :
print("\n" + "="*60)print("🔄 ÉTAPE 2 : Division des données")print("="*60)
print("Nous avons actuellement :")print(f" - {len(X)} emails avec leurs caractéristiques")print(f" - {len(y)} étiquettes (spam ou normal)")
print("\nOn va diviser en 2 groupes :")print(" - 80% pour ENTRAÎNER le modèle (il apprend avec ces emails)")print(" - 20% pour TESTER le modèle (il devine ces emails sans les avoir vus)")
# Diviser automatiquement : 80% entraînement, 20% testX_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, # 20% pour le test random_state=42 # Pour avoir toujours la même division (reproductible))
print(f"\n✅ Division terminée :")print(f" 📚 Entraînement : {len(X_train)} emails")print(f" 🧪 Test : {len(X_test)} emails")
print(f"\nDétail des données d'entraînement :")print(f" - Spams dans l'entraînement : {sum(y_train)} emails")print(f" - Normaux dans l'entraînement : {len(y_train) - sum(y_train)} emails")
print(f"\nDétail des données de test :")print(f" - Spams dans le test : {sum(y_test)} emails")print(f" - Normaux dans le test : {len(y_test) - sum(y_test)} emails")
print(f"\n🎯 ÉTAPE 2 TERMINÉE !")print("Nos données sont prêtes pour entraîner le modèle !")
Étape 3 : Choisir et entraîner le modèle
Ce qui se passe dans cette étape :
- Choisir un algorithme (comme choisir un prof pour apprendre)
- L’entraîner avec nos données d’entraînement
- Le modèle apprend les patterns entre les caractéristiques et les réponses
Analogie simple : C’est comme montrer à un enfant 100 photos de chiens et chats en lui disant “ça c’est un chien, ça c’est un chat”. Après, il saura reconnaître de nouveaux animaux.
Action pratique : Continuez avec ce code après l’étape 2 :
print("\n" + "="*60)print("🤖 ÉTAPE 3 : Création et entraînement du modèle")print("="*60)
print("Nous allons utiliser la 'Régression Logistique'.")print("C'est un algorithme simple mais puissant pour la classification.")print("(Il existe d'autres algorithmes, mais celui-ci est parfait pour débuter)")
# Créer le modèle (c'est comme créer un cerveau vide)model = LogisticRegression()print("\n🧠 Modèle créé (cerveau vide prêt à apprendre)")
print(f"\nMaintenant, on va l'entraîner avec nos données d'entraînement :")print(f" - {len(X_train)} emails avec leurs caractéristiques")print(f" - {len(y_train)} étiquettes correspondantes (spam ou normal)")
print("\n🔄 Entraînement en cours...")print("Le modèle analyse chaque email et apprend à associer :")print(" - Beaucoup de mots suspects + beaucoup d'exclamations = SPAM")print(" - Peu de mots suspects + langage normal = EMAIL NORMAL")
# Entraîner le modèle sur les données d'entraînementmodel.fit(X_train, y_train)
print("\n✅ ENTRAÎNEMENT TERMINÉ !")print("Le modèle a appris les patterns dans nos données.")print("Il est maintenant capable de prédire si un nouvel email est un spam.")
print(f"\n🎯 ÉTAPE 3 TERMINÉE !")print("Notre modèle est prêt à faire des prédictions !")
Étape 4 : Tester le modèle sur de nouveaux emails
Ce qui se passe dans cette étape :
- Utiliser le modèle entraîné sur des emails qu’il n’a JAMAIS vus
- Comparer ses prédictions avec les vraies réponses
- Voir s’il a bien appris ou s’il se trompe
Analogie simple : C’est l’examen ! Après avoir appris avec 80% des emails, on teste le modèle sur les 20% restants pour voir s’il a vraiment compris.
Action pratique : Continuez avec ce code après l’étape 3 :
print("\n" + "="*60)print("🧪 ÉTAPE 4 : Test du modèle sur de nouveaux emails")print("="*60)
print("Maintenant, on va tester notre modèle sur les emails qu'il n'a JAMAIS vus.")print("C'est comme un examen : on vérifie s'il a bien appris.")
print(f"\nRappel de nos données de test :")print(f" - {len(X_test)} emails pour tester")print(f" - {len(y_test)} vraies réponses (pour vérifier)")
print(f"\nLe modèle va analyser chaque email de test et dire :")print(f" 'Je pense que celui-ci est un SPAM' ou 'Je pense que celui-ci est NORMAL'")
# Prédire sur l'ensemble de testprint("\n🔮 Le modèle fait ses prédictions...")y_pred = model.predict(X_test)
print(f"\n📊 RÉSULTATS :")print(f"Prédictions du modèle : {y_pred}")print(f"Vraies réponses : {y_test}")
# Affichage plus clairprint(f"\n📋 Comparaison détaillée :")for i in range(len(y_test)): prediction_text = "SPAM" if y_pred[i] == 1 else "NORMAL" reality_text = "SPAM" if y_test[i] == 1 else "NORMAL" status = "✅" if y_pred[i] == y_test[i] else "❌"
print(f"Email {i+1}: Prédit={prediction_text:6} | Réel={reality_text:6} {status}")
# Calculer le nombre de bonnes réponsescorrect_predictions = sum(y_pred == y_test)total_predictions = len(y_test)
print(f"\n🎯 Score rapide :")print(f"Bonnes réponses : {correct_predictions}/{total_predictions}")print(f"Pourcentage : {correct_predictions/total_predictions*100:.1f}%")
print(f"\n🎯 ÉTAPE 4 TERMINÉE !")print("Nous avons testé notre modèle sur de nouveaux emails !")
Étape 5 : Analyser les performances en détail
Ce qui se passe dans cette étape :
- Calculer le score du modèle (comme une note sur 20)
- Analyser les erreurs : quand se trompe-t-il et pourquoi ?
- Comprendre les différents types d’erreurs et leur impact
Analogie simple : C’est comme corriger un examen. On compte les bonnes réponses, mais on analyse aussi les erreurs pour comprendre où l’élève a des difficultés.
Action pratique : Continuez avec ce code après l’étape 4 :
print("\n" + "="*60)print("📊 ÉTAPE 5 : Analyse détaillée des performances")print("="*60)
# Calculer l'accuracy (pourcentage de bonnes réponses)accuracy = accuracy_score(y_test, y_pred)print(f"🎯 SCORE GLOBAL (Accuracy) : {accuracy * 100:.1f}%")
if accuracy >= 0.9: print(" → Excellent ! Le modèle est très performant.")elif accuracy >= 0.8: print(" → Bon ! Le modèle fonctionne bien.")elif accuracy >= 0.7: print(" → Acceptable. Le modèle peut être amélioré.")else: print(" → Faible. Le modèle a besoin d'améliorations.")
# Analyser les types d'erreurs avec la matrice de confusioncm = confusion_matrix(y_test, y_pred)print(f"\n📊 MATRICE DE CONFUSION (analyse des erreurs) :")print(f" PRÉDICTIONS")print(f"RÉALITÉ Normal Spam")print(f"Normal {cm[0,0]:3d} {cm[0,1]:3d}")print(f"Spam {cm[1,0]:3d} {cm[1,1]:3d}")
# Expliquer chaque casetrue_negatives = cm[0,0] # Emails normaux → classés normaux ✅false_positives = cm[0,1] # Emails normaux → classés spam ❌ (erreur grave !)false_negatives = cm[1,0] # Spams → classés normaux ❌ (spam qui passe !)true_positives = cm[1,1] # Spams → classés spam ✅
print(f"\n🔍 EXPLICATION DES RÉSULTATS :")print(f"✅ Emails normaux correctement identifiés : {true_negatives}")print(f"✅ Spams correctement détectés : {true_positives}")print(f"❌ Emails normaux classés comme spam : {false_positives} (faux positifs)")print(f"❌ Spams qui ont échappé à la détection : {false_negatives} (faux négatifs)")
# Calculer des métriques avancéesif (true_positives + false_positives) > 0: precision = true_positives / (true_positives + false_positives) print(f"\n📈 PRÉCISION : {precision:.2%}") print(f" → Sur tous les emails que j'ai classés comme spam, {precision:.1%} étaient vraiment des spams")else: precision = 0 print(f"\n📈 PRÉCISION : Non calculable (aucun spam prédit)")
if (true_positives + false_negatives) > 0: recall = true_positives / (true_positives + false_negatives) print(f"📈 RAPPEL : {recall:.2%}") print(f" → Sur tous les vrais spams, j'en ai détecté {recall:.1%}")else: recall = 0 print(f"📈 RAPPEL : Non calculable (aucun vrai spam)")
# F1-Score (équilibre entre précision et rappel)if (precision + recall) > 0: f1_score = 2 * (precision * recall) / (precision + recall) print(f"📈 F1-SCORE : {f1_score:.2%}") print(f" → Score équilibré entre précision et rappel")else: print(f"📈 F1-SCORE : 0% (aucune détection)")
# Analyser les erreurs en détailprint(f"\n🔍 ANALYSE DES ERREURS :")errors = y_test != y_predif errors.any(): print(f"Nombre d'erreurs : {errors.sum()}/{len(y_test)}") error_indices = np.where(errors)[0] for idx in error_indices: actual = "Spam" if y_test[idx] == 1 else "Normal" predicted = "Spam" if y_pred[idx] == 1 else "Normal" print(f" Email de test {idx+1}: Était {actual} → Prédit comme {predicted}")else: print("🎉 AUCUNE ERREUR ! Classification parfaite sur les données de test.")
print(f"\n🎯 ÉTAPE 5 TERMINÉE !")print("Nous avons analysé en détail les performances de notre modèle !")
Étape 6 : Utiliser le modèle sur de vrais nouveaux emails
Ce qui se passe dans cette étape :
- Créer une fonction pour tester n’importe quel email
- Tester sur 5 nouveaux emails complètement différents
- Voir le modèle en action avec ses explications
Analogie simple : Maintenant que notre “détecteur de spam” est entraîné et testé, on l’utilise comme un vrai filtre email ! On lui donne de nouveaux messages et il nous dit s’ils sont suspects.
Action pratique : Continuez avec ce code après l’étape 5 :
print("\n" + "="*60)print("🚀 ÉTAPE 6 : Utilisation du modèle sur de nouveaux emails")print("="*60)
print("Maintenant, on va utiliser notre modèle comme un vrai filtre anti-spam !")print("On lui donne des emails qu'il n'a JAMAIS vus et il nous dit s'ils sont suspects.")
# Fonction pour analyser un nouvel email de manière détailléedef predict_email(email_content, model, feature_names): """Prédit si un email est un spam et affiche le détail du processus"""
print(f"📧 NOUVEL EMAIL À ANALYSER :") print(f"'{email_content}'") print("-" * 80)
# ÉTAPE 1 : Extraire les caractéristiques (comme on l'a fait en étape 1) features = extract_features(email_content) features_array = np.array([features])
# ÉTAPE 2 : Montrer ce que le modèle "voit" print("🔍 Ce que le modèle analyse :") for i, (name, value) in enumerate(zip(feature_names, features)): print(f" {name}: {value}")
# ÉTAPE 3 : Le modèle fait sa prédiction prediction = model.predict(features_array) probabilities = model.predict_proba(features_array)
# ÉTAPE 4 : Interpréter et expliquer le résultat is_spam = prediction[0] == 1 confidence = probabilities[0][1] if is_spam else probabilities[0][0]
print(f"\n🤖 RÉFLEXION DU MODÈLE :") print(f" 'En analysant les caractéristiques de cet email...'")
if is_spam: print(f"🚨 VERDICT : SPAM DÉTECTÉ (confiance : {confidence*100:.1f}%)") print(f" 'Cet email ressemble aux spams que j'ai appris à reconnaître'")
if confidence > 0.8: print(" Certitude : TRÈS ÉLEVÉE - Je suis sûr à plus de 80%") elif confidence > 0.6: print(" Certitude : MOYENNE - Je pense que c'est un spam") else: print(" Certitude : FAIBLE - Je ne suis pas très sûr") else: print(f"✅ VERDICT : EMAIL NORMAL (confiance : {confidence*100:.1f}%)") print(f" 'Cet email ressemble aux emails normaux que j'ai vus'")
print(f"\n📊 Probabilités calculées par le modèle :") print(f" Probabilité que ce soit NORMAL : {probabilities[0][0]*100:.1f}%") print(f" Probabilité que ce soit SPAM : {probabilities[0][1]*100:.1f}%") print("=" * 80)
# Collection de nouveaux emails à tester (jamais vus par le modèle)nouveaux_emails = [ "PROMOTION EXCEPTIONNELLE !!! Gagnez un iPhone GRATUIT maintenant ! Cliquez rapidement !!!", "Bonjour, merci pour votre présentation hier. Pouvez-vous m'envoyer les slides ?", "URGENT : Votre compte sera bloqué ! Confirmez vos données bancaires sur ce lien suspect !", "Rappel : votre abonnement Netflix expire dans 3 jours. Renouvelez en ligne.", "Salut ! Tu viens toujours au barbecue samedi ? Dis-moi si tu veux que j'apporte quelque chose."]
print("\n🎯 TEST EN CONDITIONS RÉELLES :")print("Voici 5 nouveaux emails. Le modèle va les analyser un par un.")print("=" * 80)
for i, email in enumerate(nouveaux_emails, 1): print(f"\n🔸 TEST {i}/5 :") predict_email(email, model, feature_names)
# Petite pause pour la lisibilité if i < len(nouveaux_emails): input("\n⏸️ Appuyez sur Entrée pour voir le test suivant...")
print(f"\n🎉 ÉTAPE 6 TERMINÉE !")print("Votre modèle de Machine Learning fonctionne comme un vrai filtre anti-spam !")print("Il peut maintenant analyser n'importe quel nouvel email.")
Félicitations ! Vous êtes officiellement un praticien de Machine Learning ! Enfin presque :)
Éviter les pièges courants
Overfitting (surapprentissage)
Le modèle apprend trop bien les données d’entraînement, y compris le bruit, et perd sa capacité de généralisation.
Symptômes :
- Performance excellente sur les données d’entraînement
- Performance médiocre sur de nouvelles données
Solutions :
# 1. Réduire la complexité du modèletree_simple = DecisionTreeClassifier(max_depth=3) # Limite la profondeur
# 2. Utiliser la régularisationfrom sklearn.linear_model import Ridge, Lasso
# Ridge : pénalise les coefficients élevésridge = Ridge(alpha=1.0)
# 3. Augmenter les données d'entraînement# 4. Utiliser la validation croiséefrom sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=5) # 5 plisprint(f"Scores de validation croisée : {scores}")print(f"Score moyen : {scores.mean():.2f}")
Underfitting (sous-apprentissage)
Le modèle est trop simple pour capturer la complexité des données.
Symptômes :
- Mauvaises performances partout (train et test)
Solutions :
- Augmenter la complexité du modèle
- Ajouter plus de features
- Réduire la régularisation
Déséquilibre des classes
Quand une classe est beaucoup plus fréquente que l’autre.
Exemple : Dans un dataset de fraudes bancaires, 99% des transactions sont légitimes.
Solutions :
from sklearn.utils import resample
# Sur-échantillonner la classe minoritaireminority_class = data[data['fraud'] == 1]majority_class = data[data['fraud'] == 0]
minority_upsampled = resample(minority_class, replace=True, n_samples=len(majority_class), random_state=42)
# Combinerbalanced_data = pd.concat([majority_class, minority_upsampled])
Conclusion
Félicitations ! Vous avez parcouru tout le chemin du débutant complet jusqu’à la création d’un modèle de Machine Learning fonctionnel.
Ce que vous savez maintenant :
- ✅ Comprendre les concepts fondamentaux du Machine Learning
- ✅ Différencier les types d’apprentissage (supervisé, non supervisé, par renforcement)
- ✅ Installer et configurer un environnement Python pour le ML
- ✅ Nettoyer et préparer des données
- ✅ Créer, entraîner et évaluer des modèles
- ✅ Connaître les algorithmes les plus courants
- ✅ Éviter les pièges classiques (overfitting, underfitting)
- ✅ Réaliser un projet complet de A à Z
Pour aller plus loin, consultez :
Le Machine Learning est un domaine vaste et en constante évolution. L’important est de pratiquer régulièrement, de rester curieux et de ne jamais avoir peur de faire des erreurs. C’est en expérimentant que vous progresserez le plus rapidement.
Bonne chance dans votre aventure en Machine Learning !