Module 4 APPRENTISAGE AUTOMATIQUE

Chapitre 1 Introduction au Machine Learning

À la fin de ce chapitre, vous serez capable de :

 Comprendre ce qu’est le Machine Learning (ML)

 Différencier les types d’apprentissage (supervisé, non supervisé, par renforcement)
 Identifier les cas d’usage typiques du ML
 Installer et configurer votre environnement de travail

1. Qu’est-ce que le Machine Learning ?

Le Machine Learning est un sous-domaine de l’intelligence artificielle (IA) qui consiste à

apprendre automatiquement à partir de données pour faire des prédictions ou des décisions
sans être explicitement programmé.

Exemple :

 Tâche : prédire le prix d’une maison

 Expérience : base de données de ventes précédentes
 Performance : évaluer avec l’erreur quadratique moyenne (MSE)

2. Les types d’apprentissage automatique

2.1 Apprentissage supervisé (Supervised Learning)

 L’algorithme apprend à partir d’un jeu de données étiqueté (avec réponses).

 But : prédire une valeur ou une classe.

Exemples :

Application Entrée (X) Sortie (Y)

Prédire un salaire Âge, diplôme Salaire
Filtrer les spams Email Spam / Non spam

Algorithmes : régression linéaire, kNN, SVM, Random Forest

2.2 Apprentissage non supervisé (Unsupervised Learning)

 L’algorithme n’a pas de labels : il découvre des structures cachées.

Exemples :

Application Données Résultat

Regrouper des clients Achats Groupes (clusters)
Réduction de dimensions Images Projection simplifiée

Algorithmes : K-Means, PCA, DBSCAN

2.3 Apprentissage par renforcement (Reinforcement Learning)

 L’algorithme apprend par essais/erreurs via récompense ou punition.

 Utilisé pour des systèmes de décision séquentielle (jeu, robot, trading).

Exemples :

Agent Environnement Objectif

Voiture autonome Route Éviter les obstacles
Joueur d’échecs Plateau Gagner la partie

3. Cas d’usage du Machine Learning

Domaine Application
Finance Détection de fraude bancaire
Santé Diagnostic médical automatisé
Marketing Recommandation de produits
Industrie Maintenance prédictive
Informatique Reconnaissance vocale, traduction automatique

4. Mise en place de l’environnement

Outils nécessaires :

 Langage : Python (le plus utilisé en ML)

 IDE : Jupyter Notebook / VSCode / Google Colab
 Librairies :
o NumPy (calculs numériques)
o Pandas (manipulation de données)
o Matplotlib / Seaborn (visualisation)
o Scikit-learn (algorithmes ML)

Mini-activité pratique

Voici un exemple simple pour illustrer la logique de prédiction :

# Exemple de régression linéaire avec scikit-learn

import numpy as np # Importation de la bibliothèque NumPy pour la gestion des tableaux

numériques

import [Link] as plt # Importation de matplotlib pour tracer les graphiques

from sklearn.linear_model import LinearRegression # Importation du modèle de régression

linéaire depuis scikit-learn

# Données simples (ex : nombre d'heures étudiées vs. score obtenu)

X = [Link]([[1], [2], [3], [4], [5]]) # Variable indépendante (entrée), sous forme de matrice
(5 lignes, 1 colonne)

y = [Link]([2, 4, 5, 4, 5]) # Variable dépendante (sortie), vecteur des scores correspondants

# Création du modèle de régression linéaire

model = LinearRegression() # Instanciation du modèle

[Link](X, y) # Entraînement du modèle sur les données : calcul de la droite qui approxime
au mieux les points

# Prédiction

y_pred = [Link](X) # Prédiction des sorties (scores) à partir des valeurs de X après
entraînement

# Affichage des résultats

[Link](X, y, color='blue', label="Données") # Affiche les données d'origine (points bleus)

[Link](X, y_pred, color='red', label="Prédiction") # Affiche la droite de régression

(prédictions) en rouge

[Link]("Heures d'étude") # Étiquette de l'axe X

[Link]("Score") # Étiquette de l'axe Y

[Link]() # Affiche la légende pour identifier les courbes

[Link]("Régression Linéaire") # Titre du graphique

[Link]() # Affiche le graphique

 Le ML apprend à partir des données pour automatiser des décisions ou prédictions.

 Il existe 3 grandes familles : supervisé, non supervisé, par renforcement.
 Python avec Scikit-learn est l’outil de base le plus accessible pour débuter.
Chapitre 2 Régression Supervisée

Ce chapitre vous permet de :

 Comprendre la régression linéaire et ses variantes

 Appliquer un modèle de régression sur des données réelles
 Évaluer la performance d’un modèle de régression
 Éviter le surapprentissage grâce à la régularisation

1. Qu’est-ce que la régression ?

La régression est une technique de Machine Learning supervisé permettant de prédire une
valeur continue à partir de variables explicatives.

Exemples concrets :

Problème Variables d'entrée (X) Variable cible (Y)

Prédire le prix d'une maison Surface, nb de chambres Prix
Estimer la consommation d'énergie Température, jour, heure kWh

2. Régression Linéaire Simple

Formule :

^y =ω . x +b

 x = variable d'entrée
 ω = coefficient (pente)
 b = biais (ordonnée à l'origine)

Étapes :

1. Entraîner le modèle (fit)

2. Prédire des valeurs (predict)
3. Évaluer la performance (score, mean_squared_error, etc.)

Exemple en Python :

import numpy as np
import [Link] as plt
from sklearn.linear_model import LinearRegression
from [Link] import mean_squared_error

# Données

X = [Link]([[1], [2], [3], [4], [5]]) # Variable

indépendante (entrée), sous forme de tableau 2D
y = [Link]([1.8, 3.9, 5.8, 8.2, 10.1]) # Variable dépendante
(valeurs observées)

# Modèle

model = LinearRegression() # Création d'un modèle de

régression linéaire

[Link](X, y) # Entraînement du modèle sur les données X

(entrée) et y (sortie réelle)

# Prédiction

y_pred = [Link](X) # Prédiction des valeurs de y à

partir de X après entraînement

# Évaluation

mse = mean_squared_error(y, y_pred) # Calcul de l'erreur

quadratique moyenne (MSE) entre les vraies valeurs et les
prédictions

print(f"Erreur quadratique moyenne : {mse:.2f}") # Affichage

de l'erreur quadratique moyenne, arrondie à deux décimales

# Affichage

[Link](X, y, color='blue', label="Données") # Affiche les

points réels en bleu

[Link](X, y_pred, color='red', label="Régression") # Affiche

la droite de régression en rouge

[Link]("X")

[Link]("y")

[Link]("Régression linéaire simple")

[Link]() # Affiche la légende

[Link]() # Affiche le graphique

3. Régression Linéaire Multiple

Lorsque vous avez plusieurs variables explicatives :

^y =ω1 x 1 +ω 2 x 2 +…+ω n x n +b

Exemple :

import pandas as pd
from sklearn.linear_model import LinearRegression

# Données
data = {
'surface': [50, 60, 80, 100, 120], # Liste des
surfaces en m²
'nb_chambres': [1, 2, 2, 3, 3], # Liste du nombre
de chambres
'prix': [150, 180, 220, 280, 310] # Liste des prix
correspondants (ex : en milliers d'euros)
}
df = [Link](data)

# X = variables explicatives (features), y = variable cible

(target)
X = df[['surface', 'nb_chambres']] # Sélection des colonnes
"surface" et "nb_chambres" comme variables d'entrée
y = df['prix'] # Sélection de la colonne "prix" comme variable
à prédire

# Modèle
model = LinearRegression() # Création d'un objet modèle de
régression linéaire
[Link](X, y) # Entraînement du modèle sur les données
d’entrée X et les sorties y

# Affichage des résultats du modèle

print("Coefficients :", model.coef_) # Affiche les
coefficients (pentes) du modèle pour chaque variable
explicative
print("Intercept :", model.intercept_) # Affiche
l'ordonnée à l'origine (valeur de y quand toutes les variables
explicatives = 0)
4. Évaluation d’un modèle de régression

Métriques courantes :

Métrique Description
MAE (Mean Absolute Error) Moyenne des erreurs absolues
MSE (Mean Squared Error) Moyenne des erreurs au carré
RMSE (Root Mean Squared Error) Racine du MSE
R² (Score de détermination) Proportion de variance expliquée

from [Link] import mean_absolute_error, r2_score #

Import des métriques d’évaluation : MAE et R²

mae = mean_absolute_error(y, y_pred) # Calcul de l'erreur

absolue moyenne (MAE) entre les valeurs réelles et les
prédictions
r2 = r2_score(y, y_pred) # Calcul du coefficient
de détermination R² pour mesurer la qualité de la prédiction

print("MAE:", mae) # Affiche la MAE : moyenne des erreurs

absolues (plus elle est petite, mieux c’est)
print("R²:", r2) # Affiche le score R² : proportion de la
variance de y expliquée par le modèle (proche de 1 = bon
modèle)

5. Régularisation : Ridge & Lasso

Lorsque le modèle s’ajuste trop bien aux données (overfitting), on utilise la régularisation.
(Améliore la généralisation et éviter la surapprentissage)

Ridge (L2) :

 Pénalise les grands coefficients

 Ajoute une contrainte à la somme des carrés des poids

Lasso (L1) :

 Peut réduire certains coefficients à 0

 Favorise la sélection de variables

from sklearn.linear_model import Ridge, Lasso # Importation

des modèles de régression Ridge et Lasso depuis scikit-learn

ridge = Ridge(alpha=1.0) # Création d'un modèle Ridge avec un

paramètre de régularisation alpha = 1.0
[Link](X, y) # Entraînement du modèle Ridge sur
les données X (features) et y (target)

lasso = Lasso(alpha=0.1) # Création d'un modèle Lasso avec un

paramètre de régularisation alpha = 0.1
[Link](X, y) # Entraînement du modèle Lasso sur
les mêmes données

print("Ridge coefficients :", ridge.coef_) # Affiche les

coefficients (poids des variables) obtenus par le modèle Ridge
print("Lasso coefficients :", lasso.coef_) # Affiche les
coefficients obtenus par le modèle Lasso

 Ridge Regression :

 Ajoute une pénalité L2 (la somme des carrés des coefficients).

 Tendance à réduire les coefficients mais sans les annuler.
 Utile quand les variables sont corrélées ou pour éviter l’overfitting.

 Lasso Regression :

 Ajoute une pénalité L1 (la somme des valeurs absolues des coefficients).
 Tendance à réduire certains coefficients à zéro → sélection automatique des
variables.
 Pratique pour simplifier les modèles et détecter les variables les plus importantes.

Exercice pratique

Prédire le prix d’un bien immobilier à partir des caractéristiques suivantes :

 Surface (m²)
 Nombre de chambres
 Année de construction

Étapes proposées :

1. Créer un DataFrame avec 10 biens fictifs

2. Appliquer une régression linéaire multiple
3. Évaluer la performance du modèle (MAE, MSE, R²)
4. Tester Ridge et Lasso

À retenir

 La régression linéaire permet de modéliser une relation entre variables.

 L’évaluation se fait avec MSE, MAE, RMSE et R².
 Ridge et Lasso permettent d’éviter le surapprentissage.
 Scikit-learn fournit tous les outils pour implémenter ces modèles.
Chapitre 3 Classification Supervisée

Ce chapitre vous permet de :

 Comprendre la classification supervisée et ses applications

 Maîtriser plusieurs algorithmes de classification
 Évaluer la performance des modèles de classification
 Implémenter des modèles simples avec Scikit-learn

1. Qu’est-ce que la classification ?

La classification est un type de machine learning supervisé où l’objectif est de prédire une
étiquette (catégorie) à partir de variables d’entrée.

Exemples :

Cas d’usage Entrées (features) Sortie (classe)

Détection d'email spam Texte de l'email Spam / Non spam
Diagnostic médical Température, tension, symptôme Malade / Sain
Recrutement Compétences, diplômes Accepté / Refusé

2. Algorithmes de classification

2.1. Logistic Regression

 Convient pour des classes binaires (0 ou 1)

 Utilise une fonction sigmoïde (un graphique pour visualiser sa forme)

from sklearn.linear_model import LogisticRegression #

Importation de la classe LogisticRegression pour la
classification binaire ou multiclasse

model = LogisticRegression() # Création d'un modèle de

régression logistique avec les paramètres par défaut

[Link](X_train, y_train) # Entraînement du modèle sur les

données d'apprentissage (X_train = variables explicatives,
y_train = étiquettes/classes)

2.2. k-Nearest Neighbors (k-NN)

 Classifie selon les k plus proches voisins

 Pas d'entraînement, sensible à la distance

from [Link] import KNeighborsClassifier

model = KNeighborsClassifier(n_neighbors=3)
2.3. Decision Tree

 Structure en arbre avec des règles conditionnelles

 Interprétable, mais sujet à l’overfitting

from [Link] import DecisionTreeClassifier

model = DecisionTreeClassifier()

2.4. Random Forest

 Ensemble de plusieurs arbres (bagging)

 Réduit l'overfitting, très efficace

from [Link] import RandomForestClassifier

model = RandomForestClassifier()

2.5. Support Vector Machine (SVM)

 Sépare les classes avec une hyperplane optimale

 Efficace pour les petits datasets bien séparables

from [Link] import SVC

model = SVC()

2.6. Naive Bayes

 Basé sur le théorème de Bayes

 Rapide et efficace pour les textes, spam, etc.

from sklearn.naive_bayes import GaussianNB

model = GaussianNB()

3. Évaluation d’un modèle de classification

Métriques :

Nom Utilité
Accuracy Proportion de bonnes prédictions
Precision Précision sur les vrais positifs
Recall Sensibilité / Rappel
F1-score Moyenne harmonique précision/rappel
Matrice de confusion Détail des vrais/faux positifs/négatifs
ROC & AUC Mesure la performance globale du modèle binaire

from [Link] import classification_report,

confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

4. Exemple pratique : Classification d’iris

from [Link] import load_iris

from sklearn.model_selection import train_test_split
from [Link] import RandomForestClassifier
from [Link] import classification_report

# Chargement du dataset
iris = load_iris()
X = [Link]
y = [Link]

# Séparation des données

X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.3)

# Modèle
model = RandomForestClassifier()
[Link](X_train, y_train)

# Prédiction
y_pred = [Link](X_test)

# Évaluation
print(classification_report(y_test, y_pred,
target_names=iris.target_names))

5. Visualisation : Matrice de confusion

La matrice de confusion (ou confusion matrix) est un outil fondamental pour évaluer les
performances d’un modèle de classification supervisée. Elle permet de visualiser les
prédictions du modèle par rapport aux valeurs réelles.

Exemple

Contexte : Prédiction binaire (malade ou sain)

Supposons que l’on a un modèle qui classe des patients en deux catégories :

 1 = malade
 0 = sain

Étape 1 : Importer les bibliothèques

from [Link] import confusion_matrix, ConfusionMatrixDisplay
import [Link] as plt

Étape 2 : Résultats simulés

# Vérités terrain (valeurs réelles)
y_true = [0, 1, 0, 1, 0, 1, 1, 0, 1, 0]

# Prédictions du modèle
y_pred = [0, 1, 0, 0, 0, 1, 1, 1, 1, 0]

Étape 3 : Calcul et affichage de la matrice de confusion

# Création de la matrice de confusion
cm = confusion_matrix(y_true, y_pred)

# Affichage graphique
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Sain",
"Malade"])
[Link](cmap='Blues')
[Link]("Matrice de confusion")
[Link]()

Interprétation de la matrice

Supposons que la matrice de confusion affichée est la suivante :

Prédit
Sain Malade
Réel Sain 4 1
Malade 1 4

Voici comment lire cette matrice :

Prédit Sain Prédit Malade

Réel Sain 4 (TN) 1 (FP)
Réel Malade 1 (FN) 4 (TP)

TP (True Positives) : Malades correctement détectés (4)

 TN (True Negatives) : Personnes saines correctement détectées (4)

 FP (False Positives) : Faux malades, alors qu’ils sont sains (1)
 FN (False Negatives) : Malades non détectés (1)

Métriques dérivées de la matrice

from [Link] import accuracy_score, precision_score, recall_score,
f1_score

print("Accuracy :", accuracy_score(y_true, y_pred))

print("Précision (malades détectés correctement) :",
precision_score(y_true, y_pred))
print("Rappel (sensibilité) :", recall_score(y_true, y_pred))
print("F1-score :", f1_score(y_true, y_pred))

# Importation des fonctions d'évaluation à partir de la bibliothèque scikit-learn :

# - accuracy_score : pour calculer la précision globale du modèle

# - precision_score : pour calculer la précision (taux de vrais positifs parmi les positifs
prédits)

# - recall_score : pour calculer le rappel (sensibilité, taux de détection des vrais positifs)

# - f1_score : pour calculer le F1-score, moyenne harmonique entre précision et rappel

from [Link] import accuracy_score, precision_score, recall_score, f1_score

# Calcul et affichage de la précision globale :

# C'est le pourcentage de bonnes prédictions (positives et négatives confondues).

print("Accuracy :", accuracy_score(y_true, y_pred))

# Calcul et affichage de la précision :

# Elle indique parmi toutes les personnes que le modèle a prédites comme "malades",
combien le sont réellement.

# Formule : Précision = TP / (TP + FP)

print("Précision (malades détectés correctement) :", precision_score(y_true, y_pred))

# Calcul et affichage du rappel :

# Il indique parmi tous les vrais malades, combien ont été correctement prédits.

# Formule : Rappel = TP / (TP + FN)

print("Rappel (sensibilité) :", recall_score(y_true, y_pred))

# Calcul et affichage du F1-score :

# C'est une moyenne harmonique entre la précision et le rappel.

# Il est utile quand il y a un déséquilibre entre les classes.

# Formule : F1 = 2 * (précision * rappel) / (précision + rappel)

print("F1-score :", f1_score(y_true, y_pred))

import seaborn as sns

import [Link] as plt
from [Link] import confusion_matrix

cm = confusion_matrix(y_test, y_pred)

[Link](cm, annot=True, fmt="d", cmap="Blues",

xticklabels=iris.target_names, yticklabels=iris.target_names)
[Link]("Prédit")
[Link]("Réel")
[Link]("Matrice de confusion")
[Link]()

6. TP / Activité pratique

Construire un modèle pour prédire si un individu est diabétique (jeu de données Pima Indians
Diabetes).

Étapes proposées :

1. Charger le dataset depuis un fichier CSV

2. Nettoyer les données si nécessaire
3. Appliquer un modèle de classification (LogisticRegression ou RandomForest)
4. Évaluer avec précision, rappel, f1-score
5. Visualiser la matrice de confusion

À retenir

 La classification permet de prédire des catégories à partir de données.

 Il existe de nombreux modèles, chacun adapté à un contexte particulier.
 L’évaluation va au-delà de la simple accuracy : précision, rappel, F1-score,
confusion matrix sont essentiels.
 Scikit-learn fournit tous les outils pour expérimenter rapidement.
Chapitre 4 Apprentissage non supervisé

À la fin de ce chapitre, vous serez capable de :

 Comprendre les principes de l’apprentissage non supervisé

 Utiliser les algorithmes de clustering (groupement)
 Réduire la dimensionnalité des données
 Visualiser des structures cachées dans un jeu de données
 Appliquer ces méthodes à des cas pratiques

1. Qu’est-ce que l’apprentissage non supervisé ?

C’est une catégorie de machine learning où les données n’ont pas de labels. L’objectif est de
découvrir des structures cachées (groupes, similarités, patterns(motif ou désigne une structure
régulière)).

2. Applications typiques

Domaine Application
Marketing Segmentation de clients
Santé Regroupement de patients par profil
Cybersécurité Détection d’anomalies
E-commerce Recommandation de produits
Réseaux sociaux Regroupement de communautés

3. Algorithmes de Clustering

3.1. K-Means Clustering

 Algorithme itératif qui regroupe les données en K clusters.

 Chaque point est affecté au centre (centroïde) le plus proche.
 Sensible à l’échelle des données et au choix de K.

from [Link] import KMeans

import [Link] as plt
from [Link] import make_blobs

# Création de données simulées

X, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.6)

# Modèle KMeans
kmeans = KMeans(n_clusters=3)
[Link](X)
y_kmeans = [Link](X)

# Visualisation
[Link](X[:, 0], X[:, 1], c=y_kmeans, cmap='viridis')
[Link](kmeans.cluster_centers_[:, 0],
kmeans.cluster_centers_[:, 1], s=200, c='red')
[Link]("K-Means Clustering")
[Link]()

Explication du code :

make_blobs est une fonction de [Link] qui génère des

données synthétiques pour le clustering.

n_samples=300 : on génère 300 points de données.

centers=3 : les points seront regroupés autour de 3 centres

(c’est-à-dire 3 vrais groupes).

cluster_std=0.6 : écart-type (dispersion) autour de chaque

centre.

X contient les coordonnées des points générés (features 2D

ici).

_ signifie qu'on ignore les étiquettes réelles retournées par

make_blobs, car KMeans est non supervisé.

# Modèle KMeans

kmeans = KMeans(n_clusters=3)

On crée un modèle de clustering K-Means.

n_clusters=3 signifie que l’on souhaite regrouper les données

en 3 clusters.

[Link](X)

Le modèle apprend les centres des clusters en analysant les

points X.

Cela applique l’algorithme K-Means pour regrouper les points

selon leur proximité.

y_kmeans = [Link](X)

Chaque point est assigné à un cluster (0, 1 ou 2) selon le

centre le plus proche.

y_kmeans contient les étiquettes de clusters prédites pour

chaque point.
# Visualisation

[Link](X[:, 0], X[:, 1], c=y_kmeans, cmap='viridis')

Trace un nuage de points à partir de X.

Les couleurs sont définies par les clusters (y_kmeans).

cmap='viridis' applique une palette de couleurs.

[Link](kmeans.cluster_centers_[:, 0],
kmeans.cluster_centers_[:, 1], s=200, c='red')

Affiche les centres de clusters calculés par le modèle en

rouge.

s=200 augmente la taille des points.

kmeans.cluster_centers_ contient les coordonnées des centres

trouvés.

[Link]("K-Means Clustering")

[Link]()

Titre du graphique et affichage.

Résultat :

Ce code montre comment le modèle K-Means regroupe

automatiquement des données 2D en 3 clusters sans connaître les
étiquettes réelles.

3.2. Hiérarchical Clustering (Agglomératif)

 Crée une arborescence (dendrogramme) de fusions de clusters.

 Ne nécessite pas toujours de spécifier K à l'avance.
 Peut être plus coûteux en temps pour de grands datasets.

from [Link] import dendrogram, linkage

import [Link] as plt

linked = linkage(X, method='ward')

dendrogram(linked)
[Link]("Dendrogramme hiérarchique")
[Link]("Points")
[Link]("Distance")
[Link]()
3.3. DBSCAN (Density-Based Spatial Clustering)

 Détecte des zones de forte densité.

 Capable de trouver des clusters de forme arbitraire.
 Bon pour la détection d’anomalies.

from [Link] import DBSCAN

db = DBSCAN(eps=0.5, min_samples=5)
y_db = db.fit_predict(X)

4. Réduction de dimensionnalité

4.1. PCA (Principal Component Analysis)

 Réduit les dimensions tout en préservant la variance maximale.

 Très utilisé pour visualiser des données multivariées.

from [Link] import PCA

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

[Link](X_pca[:, 0], X_pca[:, 1])

[Link]("Projection PCA")
[Link]("Composante 1")
[Link]("Composante 2")
[Link]()

4.2. t-SNE (t-Distributed Stochastic Neighbor Embedding)

 Pour visualiser des clusters sur des données très complexes (images, texte…).
 Conserve la proximité locale des points.

from [Link] import TSNE

tsne = TSNE(n_components=2, perplexity=30)

X_tsne = tsne.fit_transform(X)

[Link](X_tsne[:, 0], X_tsne[:, 1])

[Link]("Projection t-SNE")
[Link]()

5. Comment évaluer un clustering ?

Contrairement au ML supervisé, ici on n’a pas de “vraie réponse”.

Métriques internes :

 Inertia (pour K-Means) : somme des distances intra-cluster

 Silhouette Score : mesure la cohésion et séparation des clusters

from [Link] import silhouette_score

score = silhouette_score(X, y_kmeans)

print("Silhouette score :", score)

6. TP : Segmentation de clients

Appliquer le clustering K-Means pour segmenter des clients selon leur comportement
d’achat.

Étapes proposées :

1. Charger un dataset (ex : Mall_Customers.csv)

2. Prétraiter (normalisation)
3. Utiliser KMeans avec plusieurs valeurs de K
4. Afficher les clusters
5. Évaluer avec silhouette score

À retenir

 L’apprentissage non supervisé explore les données sans “réponses”.

 K-Means est l’algorithme de clustering le plus courant.
 PCA et t-SNE aident à visualiser des données complexes.
 Les résultats doivent être interprétés avec prudence.
Chapitre 5 Réseaux de Neurones & Deep Learning (Introduction)

Ce chapitre vous permet de :

 Comprendre le fonctionnement d’un réseau de neurones artificiels

 Connaître les concepts de base du Deep Learning
 Créer un réseau simple avec TensorFlow/Keras
 Appliquer un modèle de classification sur un dataset comme MNIST

1. Qu’est-ce qu’un réseau de neurones artificiels (ANN) ?

Un réseau de neurones est un ensemble de neurones artificiels interconnectés, inspirés du

cerveau humain. Il transforme une entrée (vecteur) en sortie via des fonctions d’activation
et ajustement de poids.

Structure d’un réseau de neurones

Type de couche Rôle

Input Layer Reçoit les données
Hidden Layers Traitent les données avec des neurones
Output Layer Donne la sortie finale (classe, valeur…)

Exemple :

Un réseau pour reconnaître des chiffres manuscrits :

 Entrée : image 28x28 pixels = 784 pixels

 Sortie : chiffre de 0 à 9 (10 neurones)

2. Fonctionnement d’un réseau

Étapes :

1. Propagation avant (Forward Propagation) : Calcul de la sortie

2. Calcul de l’erreur : Différence entre sortie attendue et prédite
3. Rétropropagation (Backpropagation) : Mise à jour des poids
4. Répétition (Epochs) : Plusieurs passages pour converger

3. Fonctions d’activation

Fonction Utilité
ReLU Rapide, utilisée dans les couches cachées
Sigmoïde Pour les sorties binaires
Softmax Pour des sorties multi-classes

4. Librairies du Deep Learning

 Librairie Description
TensorFlow Framework de Google pour l’apprentissage automatique
Keras Interface haut-niveau de TensorFlow pour créer des modèles rapidement

5. Exemple pratique : Classification de chiffres manuscrits (MNIST)

import tensorflow as tf
from [Link] import mnist
from [Link] import Sequential
from [Link] import Dense, Flatten
from [Link] import to_categorical

# Chargement des données

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Prétraitement
X_train = X_train / 255.0
X_test = X_test / 255.0
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

# Modèle
model = Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation='relu'),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])

# Compilation
[Link](optimizer='adam',
loss='categorical_crossentropy', metrics=['accuracy'])

# Entraînement
[Link](X_train, y_train, epochs=5, batch_size=32,
validation_split=0.2)

# Évaluation
loss, accuracy = [Link](X_test, y_test)
print(f"Test Accuracy: {accuracy*100:.2f}%")

6. Visualisation de prédictions
import [Link] as plt
import numpy as np

predictions = [Link](X_test)

[Link](X_test[0], cmap='gray')
[Link](f"Prédit : {[Link](predictions[0])}")
[Link]()

7. Concepts importants

Terme Signification
Epoch Une passe complète sur le jeu de données
Batch Size Nombre d’échantillons traités avant mise à jour des poids
Loss function Fonction à minimiser (ex: cross-entropy)
Optimizer Algorithme d’optimisation (SGD, Adam, etc.)

8. Limitations et précautions

 Les réseaux de neurones nécessitent beaucoup de données

 Attention à l’overfitting
 Importance de la normalisation des données
 Les hyperparamètres (nombre de neurones, learning rate, etc.) influencent les
performances

9. TP : Reconnaissance de chiffres manuscrits

1. Charger les données MNIST (ou Fashion-MNIST)

2. Construire un réseau avec au moins 2 couches cachées
3. Tester ReLU et Sigmoïde comme activation
4. Afficher les erreurs et la courbe de validation

À retenir

 Un réseau de neurones est une suite de couches transformant l’entrée vers une sortie.
 Les fonctions d’activation comme ReLU et Softmax sont essentielles.
 Keras (via TensorFlow) permet de construire des modèles très facilement.
 Le dataset MNIST est un bon point de départ.
Chapitre 6 Outils avancés et techniques pratiques

Objectifs :

 Créer des pipelines de traitement avec Scikit-learn

 Sauvegarder et recharger vos modèles
 Utiliser des outils pour automatiser l'entraînement
 Intégrer le traitement de texte (NLP de base)
 Manipuler des ensembles de données complexes

1. Pipelines avec Scikit-learn

Un pipeline est une chaîne de traitements : nettoyage, encodage, normalisation,

modélisation…

Avantages :

 Automatisation
 Reproductibilité
 Prévention des fuites de données (data leakage)

Exemple :

from [Link] import Pipeline

from [Link] import StandardScaler
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
('scaler', StandardScaler()),
('classifier', LogisticRegression())
])

[Link](X_train, y_train)
y_pred = [Link](X_test)

2. Sauvegarde et chargement de modèles

Utile pour la mise en production ou l’inférence ultérieure.

Avec joblib :

import joblib

# Sauvegarde
[Link](model, 'modele_sauvegarde.pkl')

# Chargement
model_reloaded = [Link]('modele_sauvegarde.pkl')
3. Traitement de texte (NLP de base)

Le NLP (Natural Language Processing) est important pour analyser du texte (emails, tweets,
documents...).

Étapes typiques :

 Nettoyage (suppression ponctuations, minuscules)

 Tokenisation (découper en mots)
 Stop words removal
 Transformation : Bag of Words, TF-IDF

Exemple TF-IDF + Naive Bayes :

from sklearn.feature_extraction.text import TfidfVectorizer

from sklearn.naive_bayes import MultinomialNB
from [Link] import make_pipeline

textes = ["ce produit est génial", "je déteste ce produit",

"super service", "nul"]
labels = [1, 0, 1, 0]

model = make_pipeline(TfidfVectorizer(), MultinomialNB())

[Link](textes, labels)

print([Link](["j'adore ce service"])) # --> [1]

4. Encodage de variables catégorielles

4.1. Label Encoding

from [Link] import LabelEncoder

le = LabelEncoder()
y_encoded = le.fit_transform(["chat", "chien", "chat",
"oiseau"])

4.2. One-Hot Encoding

import pandas as pd
df = [Link]({'animal': ['chat', 'chien', 'chat',
'oiseau']})
df_encoded = pd.get_dummies(df)
5. Cross-validation & Grid Search

Cross-validation (validation croisée)

Permet de vérifier la robustesse d’un modèle.

from sklearn.model_selection import cross_val_score

score = cross_val_score(model, X, y, cv=5).mean()

Grid Search : optimiser les hyperparamètres

from sklearn.model_selection import GridSearchCV

params = {'n_neighbors': [3, 5, 7]}

grid = GridSearchCV(KNeighborsClassifier(), param_grid=params,
cv=5)
[Link](X_train, y_train)

print(grid.best_params_)

6. Gérer les classes déséquilibrées

Lorsque certaines classes sont surreprésentées (ex : 90% vs 10%), la précision peut être
trompeuse.

Solutions :

 Oversampling (SMOTE)
 Undersampling
 Balanced accuracy / weighted F1-score

from imblearn.over_sampling import SMOTE

sm = SMOTE()
X_resampled, y_resampled = sm.fit_resample(X_train, y_train)

7. Chargement de jeux de données réels

7.1. Depuis [Link]

from [Link] import load_wine

data = load_wine()
X = [Link]
y = [Link]

7.2. Depuis un fichier CSV

import pandas as pd
df = pd.read_csv('[Link]')
8. Bonnes pratiques pour vos projets ML

 Créer des fonctions réutilisables

 Organiser les étapes en [Link], [Link], [Link]
 Ajouter des logs et des graphiques d'apprentissage
 Séparer clairement entraînement / validation / test
 Évaluer le coût de l’erreur selon le contexte métier

9. TP proposé

Créer un pipeline complet pour :

 Charger un dataset texte (ex. : critiques de films IMDB)

 Appliquer TF-IDF + classification (Naive Bayes)
 Évaluer la performance
 Sauvegarder le modèle
 Recharger pour tester une prédiction

À retenir

 Les pipelines permettent d’automatiser les chaînes de traitement.

 joblib sert à sauvegarder les modèles entraînés.
 Le traitement de texte nécessite des vecteurs (TF-IDF).
 Le choix des bons hyperparamètres est crucial (GridSearch, CV).
 Des classes déséquilibrées nécessitent des techniques de rééquilibrage.
Chapitre 7 Validation de modèles et interprétabilité

Objectifs :

 Évaluer correctement les performances d’un modèle

 Choisir la bonne métrique selon le type de problème
 Utiliser la validation croisée
 Éviter les biais d’évaluation (overfitting, leakage)
 Comprendre les prédictions d’un modèle (interprétabilité locale et globale)

1. Métriques d’évaluation selon le type de problème

1.1 Pour la régression :

 MSE (Mean Squared Error)

 RMSE (Racine de MSE)
 MAE (Mean Absolute Error)
 R² (Score de détermination)

from [Link] import mean_squared_error, r2_score

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

1.2 Pour la classification :

 Accuracy
 Precision, Recall
 F1-score
 ROC AUC, Matrice de confusion

from [Link] import classification_report,

confusion_matrix
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

2. Validation croisée (Cross-validation)

Technique robuste d’évaluation pour éviter l’overfitting.

Exemple :

python
CopierModifier
from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=5)
print("Moyenne score CV :", [Link]())
3. Techniques d’échantillonnage

 Hold-out (train/test)
 K-Fold (validation croisée classique)
 Stratified K-Fold (préserve les proportions de classes)
 Leave-One-Out (LOO)

4. Biais fréquents dans l’évaluation

 Overfitting : sur-apprentissage sur les données d'entraînement

 Data leakage : information future utilisée par erreur
 Imbalanced classes : affecte la précision

Solution : évaluer avec les bonnes métriques et split bien fait.

5. Interprétabilité des modèles

5.1 Interprétabilité globale

Comprendre comment le modèle prend ses décisions globalement.

 Feature Importance (importance des variables)

 Coefficients des modèles linéaires
 permutation importance

from [Link] import permutation_importance

result = permutation_importance(model, X_test, y_test)

5.2 Interprétabilité locale

Comprendre une prédiction individuelle.

Outils :

 SHAP (SHapley Additive exPlanations)

 LIME (Local Interpretable Model-agnostic Explanations)

import shap
explainer = [Link](model, X_train)
shap_values = explainer(X_test)
[Link](shap_values[0])

Ces méthodes expliquent quelles variables ont le plus influencé la prédiction d’un cas
particulier.

6. Visualisation de la performance

 Courbe ROC / AUC

 Matrice de confusion (heatmap)
  Courbe de précision/rappel
 Learning curves

from [Link] import RocCurveDisplay

RocCurveDisplay.from_estimator(model, X_test, y_test)

7. TP proposé

Sujet : Évaluer un modèle de classification binaire sur des données médicales

Objectif : Prédire une maladie (ex : diabète)

 Séparer données (train/test stratifié)

 Entraîner un modèle (Random Forest)
 Évaluer via F1-score + AUC
 Afficher la matrice de confusion
 Interpréter les prédictions avec SHAP

À retenir

 L’évaluation dépend du contexte métier (précision vs rappel…).

 Utilisez la validation croisée pour fiabiliser vos scores.
 Apprenez à interpréter les modèles pour éviter la boîte noire.
 L’interprétabilité est un facteur clé d’adoption en entreprise.
Chapitre 7 Introduction à l’Apprentissage par Renforcement

Objectifs :

 Comprendre les concepts fondamentaux de l’apprentissage par renforcement

 Décrire l’interaction entre un agent, un environnement et des récompenses
 Différencier les types d’algorithmes RL (Q-learning, SARSA, Policy Gradient)
 Appliquer un algorithme simple sur un environnement type gym

1. Qu’est-ce que l’Apprentissage par Renforcement ?

L’apprentissage par renforcement est une méthode d’apprentissage basée sur des
interactions. Un agent apprend en recevant des récompenses ou punitions après avoir pris
des décisions.

But : Maximiser la récompense cumulée sur le long terme

2. Les composants du RL

Élément Description
Agent Celui qui agit
Environnement Le monde avec lequel l’agent interagit
État (state) Situation actuelle
Action Décision de l’agent
Récompense Feedback (valeur numérique)
Politique (π) Stratégie de l’agent
Fonction de valeur (V, Q) Estimation du bénéfice futur

3. Processus de Décision de Markov (MDP)

Le RL repose sur un MDP :

 Ensemble d’états S
 Ensemble d’actions A
 Fonction de transition T(s, a, s')
 Fonction de récompense R(s, a)
 Objectif : apprendre une politique π(s) optimale

4. Paradigme de l’apprentissage

4.1 Exploration vs Exploitation

 Exploitation : choisir l’action qui donne le meilleur gain connu

 Exploration : essayer de nouvelles actions pour découvrir de meilleures stratégies
4.2 Politique :

 Déterministe : π(s) = a
 Stochastique : π(a|s) = probabilité de choisir a dans s

5. Algorithmes classiques

5.1 Q-Learning (off-policy)

Q(s,a) ← Q(s,a) + α[r + γ * max Q(s’,a’) - Q(s,a)]

5.2 SARSA (on-policy)

Q(s,a) ← Q(s,a) + α[r + γ * Q(s’,a’) - Q(s,a)]

5.3 Deep Q-Network (DQN)

 Remplace la table Q par un réseau de neurones (utilisé chez DeepMind avec Atari)

6. Implémentation simple avec OpenAI Gym

Exemple avec Q-learning sur FrozenLake

import gym
import numpy as np

env = [Link]("FrozenLake-v1", is_slippery=False)

Q = [Link]((env.observation_space.n, env.action_space.n))

alpha = 0.8
gamma = 0.95
episodes = 1000

for episode in range(episodes):

state = [Link]()[0]
done = False

while not done:

action = [Link](Q[state] + [Link](1,
env.action_space.n)[0])
new_state, reward, done, _, _ = [Link](action)
Q[state, action] += alpha * (reward + gamma *
[Link](Q[new_state]) - Q[state, action])
state = new_state

7. Notions avancées (pour aller plus loin)

 Policy Gradient Methods (REINFORCE, PPO)

 Actor-Critic
 Multi-Armed Bandits
  Model-Based RL
 Enseignement par imitation (Imitation learning)

8. Applications du RL

Domaine Exemple
Jeux vidéo AlphaGo, Dota2 (OpenAI Five), Atari
Robotique Contrôle de bras robotisé
Finance Optimisation de portefeuilles
Automobile Véhicules autonomes
Logistique Optimisation de trajets, entrepôts

9. TP proposé

Sujet : Q-Learning dans FrozenLake ou Taxi-v3

 Implémentez un Q-Learning
 Affichez la politique apprise
 Évaluez la performance (taux de réussite)
 Visualisez la progression des scores

Extensions possibles : essayer DQN avec PyTorch ou stable-baselines3

À retenir

 Le RL apprend par essais et erreurs dans un environnement inconnu

 Q-learning et SARSA sont des algorithmes fondamentaux
 Le trade-off exploration/exploitation est au cœur du RL
 Le RL est puissant mais complexe à stabiliser
Chapitre 8 Déploiement de modèles de Machine Learning

Objectifs :

 Expliquer les enjeux du déploiement de modèles ML en production

 Préparer un modèle pour l’inférence (sérialisation, dépendances)
 Créer une API pour exposer un modèle ML (avec Flask, FastAPI)
 Conteneuriser l’application avec Docker
 Déployer sur un cloud (Heroku, AWS, etc.)

1. Cycle de vie d’un projet ML

Étape Description
Prétraitement Nettoyage, encodage, scaling
Entraînement Séparation train/test, entraînement
Évaluation Validation croisée, métriques
Déploiement Mise à disposition du modèle
Monitoring Suivi des performances en production

2. Sérialisation du modèle

2.1 Outils courants

 pickle / joblib : pour les modèles scikit-learn

 [Link]() : pour PyTorch
 [Link]() : pour TensorFlow/Keras

Exemple (scikit-learn)

import joblib
[Link](model, 'modele_rf.joblib')

# Chargement
model = [Link]('modele_rf.joblib')

3. Créer une API avec Flask ou FastAPI

3.1 Exemple avec Flask

from flask import Flask, request, jsonify

import joblib

app = Flask(__name__)
model = [Link]("modele_rf.joblib")

@[Link]("/predict", methods=["POST"])
def predict():
data = [Link]
 features = [data['age'], data['taille']]
prediction = [Link]([features])
return jsonify({'prediction': int(prediction[0])})

if __name__ == "__main__":
[Link](debug=True)

3.2 Exemple avec FastAPI (plus moderne)

from fastapi import FastAPI

from pydantic import BaseModel
import joblib

app = FastAPI()
model = [Link]("modele_rf.joblib")

class InputData(BaseModel):
age: float
taille: float

@[Link]("/predict")
def predict(data: InputData):
features = [[[Link], [Link]]]
prediction = [Link](features)
return {"prediction": int(prediction[0])}

4. Conteneurisation avec Docker

4.1 Dockerfile

FROM python:3.10
WORKDIR /app
COPY . .
RUN pip install -r [Link]
CMD ["python", "[Link]"]

4.2 Commandes

docker build -t ml-api .

docker run -p 5000:5000 ml-api

5. Déploiement sur le cloud

5.1 Heroku (gratuit et simple)

 Créez un fichier Procfile :

web: python [Link]

  Déploiement :

heroku login
heroku create
git push heroku main

5.2 Alternatives cloud

Plateforme Avantage
Heroku Facile pour débuter
AWS EC2 / Sagemaker Puissant mais complexe
Render Gratuit comme Heroku
Google Cloud Run Serveurless, performant
Azure ML Intégration entreprise

6. Monitoring et mise à jour

 Logs & erreurs : via logging, Sentry ou Prometheus

 Retraining : pipeline pour réentraînement automatique
 Versioning : MLflow, DVC, Git

7. TP proposé

Sujet : Déploiement d’un modèle de prédiction de revenus

 Créer un modèle de classification avec scikit-learn

 Sauvegarder le modèle avec joblib
 Créer une API avec FastAPI
 Conteneuriser avec Docker
 Déployer sur Render ou He
Chapitre 9 Études de cas & Projets

Objectifs :

 Consolider vos acquis par la pratique sur des cas réels

 Apprendre à gérer un projet complet de ML de A à Z
 Développer des compétences en nettoyage, modélisation, validation, interprétation
 S’exercer à la présentation des résultats et à la rédaction de rapports

1. Organisation

Chaque étude de cas comporte :

 Description du problème métier

 Analyse exploratoire des données (EDA)
 Prétraitement et nettoyage
 Sélection et entraînement de modèles
 Évaluation et optimisation
 Interprétation et communication des résultats
 Livrables : code, rapport, présentation

2. Étude de cas 1 : Prédiction du churn client (taux d’attrition)

 Contexte : Une entreprise télécom veut prédire quels clients risquent de quitter
 Données : Profil client, historique consommation, plaintes, abonnements
 Objectif : Construire un modèle de classification binaire (churn / non churn)
 Points clés : Gestion des classes déséquilibrées, métriques adaptées (F1-score),
interprétabilité (SHAP)

3. Étude de cas 2 : Analyse prédictive des ventes

 Contexte : Prévoir les ventes mensuelles d’un magasin

 Données : Historique des ventes, promotions, saisonnalité, météo
 Objectif : Modèle de régression pour prévoir le chiffre d’affaires
 Points clés : Feature engineering temporel, validation temporelle, gestion des données
manquantes

4. Étude de cas 3 : Détection d’anomalies dans les transactions bancaires

 Contexte : Identifier les transactions frauduleuses

 Données : Historique des transactions, montants, localisation, heure
 Objectif : Apprentissage non supervisé (clustering) ou supervisé (classification)
 Points clés : Techniques d’oversampling, détection d’outliers, évaluation sur classes
rares

5. Étude de cas 4 : Classification d’images

 Contexte : Classer des images de fruits en différentes catégories

 Données : Images prétraitées, labels
  Objectif : Construire un réseau de neurones convolutionnel simple (CNN)
 Points clés : Data augmentation, entraînement GPU, overfitting

6. Étude de cas 5 : Traitement de texte (NLP)

 Contexte : Analyse de sentiment sur des critiques de films

 Données : Textes, labels positifs/négatifs
 Objectif : Modèle de classification texte avec TF-IDF + Naive Bayes ou réseaux de
neurones
 Points clés : Nettoyage de texte, tokenisation, métriques adaptées

7. Gestion de projet et bonnes pratiques

 Structurer un projet (dossiers, scripts, notebooks)

 Versionner le code (Git)
 Documenter et commenter
 Présenter des résultats clairs
 Gérer les données sensibles et éthiques

8. TP final : Projet complet

Objectif :

 Choisir une étude de cas ou proposer un projet personnel

 Appliquer toutes les étapes : exploration, modélisation, validation, interprétation,
déploiement simple
 Rédiger un rapport final clair et complet
 Présenter oralement (si en formation)

Résultats attendus

 Modèle performant et validé

 Code propre et reproductible
 Rapport documenté avec analyses et visualisations
 Compréhension métier et techniques démontrée
APPLICATION 01 :

Prédire le prix d’une maison à partir de sa surface (en m²) en utilisant une régression
linéaire.

# Importation des bibliothèques nécessaires

import numpy as np # Pour manipuler des tableaux
numériques
import pandas as pd # Pour créer et gérer des tableaux
de données
import [Link] as plt # Pour afficher les graphiques
from sklearn.linear_model import LinearRegression # Régression linéaire
from [Link] import mean_squared_error, r2_score # Évaluation des
performances

# Création des données (surface en m² et prix en milliers d’euros)

data = {
'surface': [30, 50, 70, 90, 110], # Entrée (variable explicative)
'prix': [100, 150, 200, 250, 300] # Sortie (variable cible)
}

# Transformation en DataFrame pandas pour faciliter l’analyse

df = [Link](data)

# Séparation des variables explicatives (X) et de la cible (y)

X = df[['surface']] # X doit être un tableau 2D (colonne surface)
y = df['prix'] # y est un tableau 1D (prix)

# Création et entraînement du modèle de régression linéaire

model = LinearRegression() # Instanciation du modèle
[Link](X, y) # Apprentissage à partir des données

# Prédiction sur les mêmes surfaces (pour évaluer)

y_pred = [Link](X) # y_pred contient les prix prédits

# Affichage des résultats

[Link](X, y, color='blue', label="Données réelles") # Données
d'origine
[Link](X, y_pred, color='red', label="Régression linéaire") # Ligne de
régression
[Link]("Surface (m²)")
[Link]("Prix (en milliers €)")
[Link]("Prix vs Surface")
[Link]()
[Link](True)
[Link]()
APPLICATIO 02 :

Prédire si un étudiant réussit ou échoue à un examen en fonction de ses heures d’étude.

Objectif

Utiliser un modèle de classification (régression logistique) pour prédire une étiquette

binaire (réussite = 1, échec = 0) à partir de données simples (heures d’étude).

# Importation des bibliothèques nécessaires

import numpy as np # Pour les tableaux numériques
import pandas as pd # Pour créer un DataFrame
import [Link] as plt # Pour les graphiques
from sklearn.linear_model import LogisticRegression # Modèle de
classification
from [Link] import accuracy_score, classification_report,
confusion_matrix # Évaluation

# Création des données

# X : heures d'étude
# y : 1 = réussite, 0 = échec
data = {
'heures': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
'réussite': [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
}

# Création du DataFrame
df = [Link](data)
python
CopierModifier
# Séparation des variables explicatives et de la cible
X = df[['heures']] # Variable d'entrée (2D)
y = df['réussite'] # Cible (1D)

# Création du modèle de régression logistique

model = LogisticRegression()
[Link](X, y) # Entraînement du modèle

# Prédictions sur les mêmes données

y_pred = [Link](X) # Classe prédite (0 ou 1)
y_prob = model.predict_proba(X) # Probabilité associée à chaque classe

# Affichage des prédictions

print("Prédictions :", y_pred)
print("Probabilités (classe 1) :", y_prob[:, 1])

# Évaluation du modèle
accuracy = accuracy_score(y, y_pred)
print(f"Taux de bonne classification : {accuracy:.2f}")

# Rapport complet de classification

print("\nRapport de classification :")
print(classification_report(y, y_pred))
# Matrice de confusion
print("Matrice de confusion :")
print(confusion_matrix(y, y_pred))

# Visualisation
[Link](X, y, color='blue', label='Données réelles') # Points
d'origine
[Link](X, y_prob[:, 1], color='red', label='Probabilité de réussite') #
Courbe sigmoïde
[Link]("Heures d'étude")
[Link]("Probabilité de réussite")
[Link]("Classification binaire - Régression logistique")
[Link]()
[Link](True)
[Link]()

Interprétation des résultats

Élément Explication

LogisticRegression() Modèle de classification supervisé

fit(X, y) Le modèle apprend à séparer les classes

predict(X) Classe estimée (0 ou 1)

predict_proba(X) Probabilité pour chaque classe

accuracy_score(y, y_pred) % de prédictions correctes

classification_report Précision, rappel, F1-score

confusion_matrix Répartition : Vrai Positif / Négatif, etc.

Exemple de sortie attendue

Prédictions : [0 0 0 0 0 1 1 1 1 1]
Probabilités (classe 1) : [0.03 0.07 0.15 0.31 0.5 0.69 0.84 0.93 0.97
0.99]
Taux de bonne classification : 1.00

Rapport de classification :
precision recall f1-score support

0 1.00 1.00 1.00 5

1 1.00 1.00 1.00 5

accuracy 1.00 10
macro avg 1.00 1.00 1.00 10
weighted avg 1.00 1.00 1.00 10

Matrice de confusion :
[[5 0]
[0 5]]
APPLICATION 03 :

Segmentation de clients à partir de leurs comportements d’achat.

Un supermarché a collecté des données sur ses clients : fréquence de visite, montant moyen
dépensé, et fidélité (note sur 100).
Vous devez segmenter ces clients pour adapter des campagnes marketing.

Objectif

 Utiliser le clustering KMeans pour segmenter des clients

 Visualiser les groupes pour interpréter les profils types
 Comprendre les applications business de l’apprentissage non supervisé

Jeu de données simulé

import pandas as pd
import numpy as np
import [Link] as plt
from [Link] import KMeans
import seaborn as sns

# Création de données clients simulées

[Link](42)
data = {
'frequence_visite': [Link](1, 15, 100), # visites par mois
'depense_moyenne': [Link](200, 50, 100), # en €
'fidélité': [Link](30, 100, 100) # score de fidélité
sur 100
}
df = [Link](data)

# Affichage
print([Link]())

Clustering avec KMeans

from [Link] import StandardScaler

# Normalisation des données

scaler = StandardScaler()
X_scaled = scaler.fit_transform(df)

# Modèle KMeans avec 3 clusters

kmeans = KMeans(n_clusters=3, random_state=42)
df['cluster'] = kmeans.fit_predict(X_scaled)

# Centres des clusters

centroids = [Link](scaler.inverse_transform(kmeans.cluster_centers_),
columns=[Link][:-1])
print("Centres des clusters :\n", centroids)
Visualisation des segments
# Visualisation 2D
[Link](data=df, x='depense_moyenne', y='fidélité', hue='cluster',
palette='Set2')
[Link]("Segmentation de clients (KMeans)")
[Link]("Dépense Moyenne (€)")
[Link]("Score de Fidélité")
[Link](True)
[Link]()

Interprétation possible des clusters

Cluster Fréquence Dépense moyenne Fidélité Interprétation

0 Haute Élevée Élevée Clients VIP
1 Moyenne Moyenne Moyenne Clients standards
2 Faible Basse Basse Clients occasionnels

Ces insights peuvent aider à personnaliser les promotions :

 Récompenses pour les VIP

 Encouragements pour les fidèles moyens
 Incitations pour les occasionnels

Explication pédagogique

Étape Rôle
StandardScaler() Normalise les données pour éviter le biais dû aux unités différentes
KMeans() Regroupe les clients par similarité
fit_predict() Apprend les clusters et attribue chaque client
hue='cluster' Colorie les clients selon leur groupe
APPLICATION 04 :

Un hôpital cherche à segmenter ses patients afin d'identifier des groupes à risque pour mettre
en place des campagnes de prévention ciblées.

Étape 1 : Importation des bibliothèques

import numpy as np
import pandas as pd
import [Link] as plt
import seaborn as sns
from [Link] import KMeans
from [Link] import StandardScaler

Étape 2 : Création de données simulées

[Link](42)

# Génération de données médicales simulées

data = {
'age': [Link](20, 80, 200), # Âge entre 20 et 80 ans
'imc': [Link](25, 5, 200), # Indice de masse corporelle
moyen = 25
'pression': [Link](120, 15, 200) # Tension artérielle
systolique
}

df = [Link](data)
print([Link]())

Commentaire :

 age : indicateur de vieillissement

 imc : reflète le surpoids ou l'obésité
 pression : indicateur de santé cardiovasculaire

Étape 3 : Normalisation des données

# Mise à l'échelle des données

scaler = StandardScaler()
X_scaled = scaler.fit_transform(df)

 Création d’un objet StandardScaler de la bibliothèque scikit-learn.

 Cet objet sert à standardiser les données, c’est-à-dire les transformer pour qu’elles aient
une moyenne nulle (0) et un écart-type égal à 1.

 Cette normalisation est importante pour que les variables, même si elles ont des unités ou
échelles différentes, soient comparables et aient un poids équivalent dans les algorithmes.

 fit_transform applique deux opérations successives sur le DataFrame df :

 1. fit : calcule la moyenne et l’écart-type de chaque colonne dans df.
2. transform : utilise ces statistiques pour centrer (soustraire la moyenne) et
réduire (diviser par l’écart-type) les données.
 Le résultat est un tableau numpy X_scaled où chaque colonne est normalisée.
 Cette étape est cruciale avant d’appliquer des algorithmes sensibles aux échelles,
comme le clustering KMeans, afin d’éviter qu’une variable domine les autres
simplement parce qu’elle a des valeurs plus grandes.

Le clustering est sensible aux échelles → on standardise toutes les colonnes.

Étape 4 : Clustering avec KMeans

kmeans = KMeans(n_clusters=3, random_state=0)

df['cluster'] = kmeans.fit_predict(X_scaled)

fit_predict() applique KMeans et affecte chaque patient à un groupe.

 Création d’un modèle KMeans avec la bibliothèque scikit-learn.

 n_clusters=3 signifie que l’on souhaite regrouper les données en 3 clusters (groupes).

 random_state=0 fixe la graine aléatoire pour que les résultats soient répétables (mêmes
clusters à chaque exécution).

 fit_predict() est une méthode qui fait deux choses :

1. fit(X_scaled) : entraîne le modèle KMeans sur les données normalisées X_scaled,

c’est-à-dire qu’il cherche les centres des 3 groupes qui minimisent la variance intra-
groupe.
2. predict(X_scaled) : attribue à chaque point (client/patient) le numéro du cluster
auquel il appartient (0, 1 ou 2 ici).

 Ces numéros de cluster sont ajoutés comme nouvelle colonne 'cluster' dans le
DataFrame df.

 Ainsi, on sait à quel groupe chaque individu appartient selon la segmentation KMeans.

Étape 5 : Visualisation des clusters

[Link](data=df, x='imc', y='pression', hue='cluster',

palette='Set2')
[Link]("Clustering des patients selon IMC et Pression")
[Link]("IMC")
[Link]("Pression artérielle")
[Link](True)
[Link]()
  Utilisation de la fonction scatterplot de la bibliothèque Seaborn pour tracer un
nuage de points.
 data=df : la source des données est le DataFrame df.
 x='imc' : les valeurs de l’axe horizontal correspondent à la colonne imc (indice de
masse corporelle).
 y='pression' : les valeurs de l’axe vertical correspondent à la colonne pression
(pression artérielle).
 hue='cluster' : les points sont colorés selon la colonne cluster, c’est-à-dire selon
le groupe auquel chaque patient appartient (résultat du clustering).
 palette='Set2' : choix d’une palette de couleurs agréable et distincte pour bien
différencier les clusters.

Étape 6 : Profil de chaque groupe

# Moyennes des variables par cluster

profil_clusters = [Link]('cluster').mean()
print(profil_clusters)

Exemple d’interprétation :

Pression
Cluster Âge moyen IMC moyen Interprétation
moyenne
Patients âgés et à risque
0 70 ans 30 145
cardiovasculaire
1 40 ans 22 110 Patients jeunes, en bonne santé
2 55 ans 28 130 Patients d’âge moyen, surpoids modéré

Conclusion

 Nous avons utilisé KMeans pour segmenter des patients sans étiquette.
 Grâce à cette méthode, on peut identifier des groupes à risque, même sans diagnostic
préalable.
 C'est une technique utile pour la prévention, le triage, ou l'analyse exploratoire.
APPLICATION 05 :

 Comprendre comment un agent d’apprentissage par renforcement peut apprendre à

modifier une image par actions successives.
 Implémenter un agent qui ajuste la luminosité d’une image pour atteindre une
luminosité cible.
 Appliquer la méthode Q-Learning dans un environnement très simple.

Contexte

L’agent reçoit une image en niveaux de gris et peut appliquer 3 actions :

 Augmenter la luminosité (+10 unités)

 Diminuer la luminosité (-10 unités)
 Ne rien faire

L’objectif est d’ajuster la luminosité moyenne de l’image pour qu’elle se rapproche d’une
valeur cible (ex : 128 sur 0–255).

La récompense est basée sur la proximité à la luminosité cible : plus l’agent se rapproche,
meilleure la récompense.

Étape 1 : Préparation des bibliothèques

import numpy as np
import [Link] as plt

Étape 2 : Création d’une image simulée (niveaux de gris)

# Image 8x8 pixels avec luminosité moyenne initiale ~ 100

image = [Link]((8, 8)) * 100

Étape 3 : Définition de l’environnement RL

class BrightnessEnv:
def __init__(self, image, target=128):
[Link] = [Link]()
[Link] = target
[Link] = self.get_brightness()

def get_brightness(self):
# Moyenne des pixels = état
return [Link]([Link])

def step(self, action):

# Actions: 0=augmenter, 1=diminuer, 2=ne rien faire
if action == 0:
[Link] = [Link]([Link] + 10, 0, 255)
elif action == 1:
[Link] = [Link]([Link] - 10, 0, 255)
# Sinon pas de changement

[Link] = self.get_brightness()
 # Récompense négative de la distance à la cible (on veut minimiser
l’écart)
reward = -abs([Link] - [Link])

# Episode terminé si on est très proche de la cible (écart ≤ 1)

done = abs([Link] - [Link]) <= 1

return [Link], reward, done

Étape 4 : Initialisation de la table Q

# États discrets : luminosité moyenne arrondie (0-255)

# 3 actions possibles : augmenter, diminuer, rien
Q = [Link]((256, 3))

Étape 5 : Paramètres RL

alpha = 0.1 # taux apprentissage

gamma = 0.9 # facteur discount
epsilon = 0.2 # exploration
episodes = 500

Étape 6 : Boucle d’apprentissage Q-Learning

env = BrightnessEnv(image)

for ep in range(episodes):
state = int([Link])
done = False

while not done:

# Politique epsilon-greedy
if [Link]() < epsilon:
action = [Link](3)
else:
action = [Link](Q[state])

next_state, reward, done = [Link](action)

next_state = int(next_state)

# Mise à jour Q
Q[state, action] = Q[state, action] + alpha * (reward + gamma *
[Link](Q[next_state]) - Q[state, action])

state = next_state

# Reset image pour nouvel épisode

[Link] = [Link]()
[Link] = env.get_brightness()

Étape 7 : Test de la politique apprise

env = BrightnessEnv(image)
state = int([Link])
done = False
actions_taken = []
while not done:
action = [Link](Q[state])
state, reward, done = [Link](action)
state = int(state)
actions_taken.append(action)

print("Actions prises pour ajuster la luminosité :", actions_taken)

print("Luminosité finale :", state)

Explications

Élément Description
État Luminosité moyenne actuelle de l’image (entier 0–255)
Actions Augmenter, diminuer ou rien (3 actions)
Négative de la distance à la luminosité cible, donc l’agent cherche à
Récompense
réduire l’écart
Q-Table Matrice 256x3 estimant la valeur d’une action dans un état donné
Politique epsilon-
Balance entre exploration aléatoire et exploitation du meilleur choix
greedy

Conclusion

 Cet exercice illustre comment un agent RL peut apprendre à modifier une image en
agissant directement sur ses pixels (ici par une abstraction simple).
 Ce principe peut être étendu à des tâches plus complexes, par exemple ajustement
automatique, restauration ou filtrage via RL.