Maitriser l’analyse de données avec python

Elisée Sènan AMADE

2025-03-02
 Python

Sènan Elisée AMADE, ISE Page ii

Contents

Introduction 1

Chapitre 1 : Installation et prise en main de Python 3

1.1 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Environnements de travail pour l’analyse de données . . . . . . . . . . . . . . . 4
1.3 Premiers pas avec Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Chapitre 2 : Manipulation des données avec Pandas 7

2.1 Installation et importation de Pandas . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Création et manipulation de DataFrames . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Sélection et filtrage des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Manipulation des valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 Transformation et agrégation des données . . . . . . . . . . . . . . . . . . . . . . 10

Chapitre 3 : Visualisation des données avec Matplotlib et Seaborn 11

3.1 Installation et importation des bibliothèques . . . . . . . . . . . . . . . . . . . . . 11
3.2 Création de graphiques avec Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Visualisation avancée avec Seaborn . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.4 Personnalisation des graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Chapitre 4 : Nettoyage et préparation des données 15

4.1 Chargement et exploration des données . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Gestion des valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3 Gestion des doublons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

iii
 Python

4.4 Conversion des types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.5 Normalisation et mise à l’échelle des données . . . . . . . . . . . . . . . . . . . 17
4.6 Encodage des variables catégoriques . . . . . . . . . . . . . . . . . . . . . . . . . 18

Chapitre 5 : Analyse exploratoire des données (EDA) 19

5.1 Chargement du jeu de données et exploration initiale . . . . . . . . . . . . . . 19
5.2 Visualisation des distributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.3 Analyse des relations entre variables . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.4 Détection des valeurs aberrantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.5 Analyse des variables catégoriques . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.6 Analyse des tendances et des séries temporelles . . . . . . . . . . . . . . . . . . 23
5.7 Synthèse de l’EDA et prochaines étapes . . . . . . . . . . . . . . . . . . . . . . . 23

Chapitre 6 : Introduction aux statistiques avec Python 25

6.1 Statistiques descriptives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.2 Statistiques inférentielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.3 Régression linéaire simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.4 Synthèse et prochaines étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Chapitre 7 : Modélisation statistique et machine learning avec Python 31

7.1 Introduction au machine learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.2 Préparation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.3 Régression linéaire pour la prédiction . . . . . . . . . . . . . . . . . . . . . . . . 33
7.4 Classification avec la régression logistique . . . . . . . . . . . . . . . . . . . . . . 33
7.5 Arbres de décision et forêts aléatoires . . . . . . . . . . . . . . . . . . . . . . . . 34
7.6 Réseau de neurones avec Scikit-Learn . . . . . . . . . . . . . . . . . . . . . . . . 35
7.7 Comparaison des modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
7.8 Conclusion et prochaines étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Chapitre 8 : Optimisation des modèles et tuning des hyperparamètres 39

8.1 Qu’est-ce que l’optimisation des hyperparamètres ? . . . . . . . . . . . . . . . 39
8.2 Validation croisée pour évaluer un modèle . . . . . . . . . . . . . . . . . . . . . 40
8.3 Recherche par grille (Grid Search) . . . . . . . . . . . . . . . . . . . . . . . . . . 40
8.4 Recherche aléatoire (Random Search) . . . . . . . . . . . . . . . . . . . . . . . . . 41

Sènan Elisée AMADE, ISE Page iv

 Python

8.5 Optimisation bayésienne avec Optuna . . . . . . . . . . . . . . . . . . . . . . . . 42

8.6 Comparaison des méthodes d’optimisation . . . . . . . . . . . . . . . . . . . . . 43
8.7 Régularisation pour éviter le sur-apprentissage . . . . . . . . . . . . . . . . . . 44
8.8 Conclusion et prochaines étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Chapitre 9 : Interprétation et Explicabilité des modèles de Machine Learning 47

9.1 Pourquoi l’interprétabilité des modèles est-elle importante ? . . . . . . . . . . 47
9.2 Méthodes d’interprétation des modèles . . . . . . . . . . . . . . . . . . . . . . . 48
9.3 Interprétation des réseaux de neurones avec Grad-CAM . . . . . . . . . . . . 50
9.4 Conclusion : Interprétabilité et Éthique dans le Machine Learning . . . . . . . 51

Chapitre 10 : Modèles non supervisés et réduction de dimension 53

10.1 Segmentation (Clustering) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
10.2 Réduction de dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
10.3 Conclusion : L’importance de l’apprentissage non supervisé . . . . . . . . . 56

Chapitre 12 : Méthodes Avancées d’Optimisation 59

12.1 Descente de Gradient Stochastique (SGD) . . . . . . . . . . . . . . . . . . . . . 59
12.2 Variantes de la Descente de Gradient . . . . . . . . . . . . . . . . . . . . . . . . 60
12.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Chapitre 13 : Régularisation dans l’Apprentissage Automatique 65

13.1 Qu’est-ce que la Régularisation ? . . . . . . . . . . . . . . . . . . . . . . . . . . 65
13.2 La Régularisation L1 (Lasso) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13.3 La Régularisation L2 (Ridge) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.4 La Régularisation ElasticNet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.5 Dropout dans les Réseaux Neuronaux . . . . . . . . . . . . . . . . . . . . . . . 68
13.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Chapitre 14 : Validation Croisée et Évaluation des Modèles 71

14.1 Qu’est-ce que la Validation Croisée ? . . . . . . . . . . . . . . . . . . . . . . . . . 71
14.2 Validation Croisée k-fold . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
14.3 Validation Croisée Leave-One-Out (LOO) . . . . . . . . . . . . . . . . . . . . . 72
14.4 Évaluation de la Performance du Modèle . . . . . . . . . . . . . . . . . . . . . 73

Sènan Elisée AMADE, ISE Page v

 Python

14.5 Validation sur des Données Non Étiquetées . . . . . . . . . . . . . . . . . . . . 74

14.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Chapitre 15 : Réseaux Neuronaux Profonds et Techniques Avancées d’Apprentissage

Supervisé 77
15.1 Introduction aux Réseaux Neuronaux Profonds . . . . . . . . . . . . . . . . . 77
15.2 Entraînement d’un Réseau Neuronal Profond . . . . . . . . . . . . . . . . . . . 78
15.3 Types de Réseaux Neuronaux Profonds . . . . . . . . . . . . . . . . . . . . . . 78
15.4 Techniques Avancées d’Apprentissage Supervisé . . . . . . . . . . . . . . . . . 79
15.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Chapitre 16 : Méthodes d’Optimisation pour l’Apprentissage Automatique 83

16.1 Introduction à l’Optimisation dans l’Apprentissage Automatique . . . . . . 83
16.2 Recherche sur la Grille (Grid Search) . . . . . . . . . . . . . . . . . . . . . . . . 84
16.3 Recherche aléatoire (Random Search) . . . . . . . . . . . . . . . . . . . . . . . 85
16.4 Optimisation Bayésienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
16.5 Algorithme Génétique pour l’Optimisation . . . . . . . . . . . . . . . . . . . . 88
16.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Chapitre 17 : Évaluation des Modèles d’Apprentissage Automatique 91

17.1 Introduction à l’Évaluation des Modèles . . . . . . . . . . . . . . . . . . . . . . . 91
17.2 Validation Croisée (Cross-Validation) . . . . . . . . . . . . . . . . . . . . . . . . 92
17.3 Matrice de Confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
17.4 Mesures de Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
17.5 Courbe ROC et AUC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
17.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

Chapitre 18 : Mise en Production des Modèles d’Apprentissage Automatique 97

18.1 Introduction à la Mise en Production . . . . . . . . . . . . . . . . . . . . . . . . 97
18.2 Sauvegarde et Chargement du Modèle . . . . . . . . . . . . . . . . . . . . . . . 98
18.3 Déploiement avec une API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
18.4 Déploiement sur le Cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
18.5 Surveillance du Modèle en Production . . . . . . . . . . . . . . . . . . . . . . . . 101
18.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

Sènan Elisée AMADE, ISE Page vi

 Python

Chapitre 19 : Techniques Avancées de Machine Learning 103

19.1 Introduction à l’Apprentissage Profond (Deep Learning) . . . . . . . . . . . 103
19.2 Réseaux Neuronaux Profonds (DNN) . . . . . . . . . . . . . . . . . . . . . . . . 104
19.3 Réseaux Convolutifs (CNN) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
19.4 Réseaux Neuronaux Récurrents (RNN) . . . . . . . . . . . . . . . . . . . . . . 106
19.5 Amélioration des Performances du Modèle . . . . . . . . . . . . . . . . . . . . 107
19.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

Conclusion 109

Sènan Elisée AMADE, ISE Page vii

 Python

Sènan Elisée AMADE, ISE Page viii

Introduction

L’analyse de données est aujourd’hui au cœur de nombreuses décisions stratégiques, aussi bien dans
les entreprises que dans la recherche académique. Grâce à l’essor des technologies numériques et à la
disponibilité massive de données, les compétences en analyse de données sont devenues essentielles
pour de nombreux métiers : data analyst, data scientist, économiste, ingénieur, etc.

Python, l’un des outils d’analyse de données s’est imposé comme incontournable pour la manipulation
et l’analyse des données. Sa flexibilité, sa simplicité et l’énorme communauté qui l’entoure en font un
langage idéal pour les débutants comme pour les experts. Ce livre a pour objectif de vous accompagner
dans votre apprentissage de l’analyse de données avec Python, en vous fournissant des bases solides et
des études de cas pratiques.

Pourquoi vous devez utiliser Python pour l’analyse de données ?

Python est particulièrement apprécié pour :

- Sa facilité d’apprentissage : Une syntaxe claire et intuitive.
- Sa richesse en bibliothèques : Pandas, NumPy, Matplotlib, Seaborn, Scikit-learn, TensorFlow. . .
- Son intégration avec d’autres technologies : Bases de données, API, cloud computing. . .
- Son adoption massive par les entreprises et la recherche : Utilisé par Google, Facebook,
Netflix, etc.

Public cible

Ce livre est destiné à :

- Ceux qui débutent en analyse de données et veulent apprendre Python.

1
 Python

- Les professionnels souhaitant améliorer leurs compétences en data science.

- Les étudiants et chercheurs qui analysent des données pour leurs projets.

Outils nécessaires

Pour suivre ce livre, vous aurez besoin de :

- Python (version 3.x)
- Jupyter Notebook ou Google Colab
- Bibliothèques Python : Pandas, NumPy, Matplotlib, Seaborn, Scikit-learn

Nous verrons comment installer et configurer ces outils au début du livre.

Sènan Elisée AMADE, ISE Page 2

Chapitre 1 : Installation et prise en main
de Python

L’un des grands avantages de Python est sa simplicité d’installation et sa compatibilité avec plusieurs
plateformes (Windows, macOS, Linux). Dans ce chapitre, nous allons voir comment installer Python
et les principaux outils nécessaires pour l’analyse de données.

1.1 Installation de Python

Python 3.x est la version recommandée pour l’analyse de données. Voici comment l’installer sur votre
machine.

1.1.1 Installation avec Anaconda (Recommandé)

Anaconda est une distribution Python qui intègre directement les bibliothèques essentielles pour la
data science.
Étapes d’installation :
1. Rendez-vous sur le site officiel : https://www.anaconda.com
2. Téléchargez la version correspondant à votre système d’exploitation.
3. Suivez les instructions d’installation.
4. Une fois installé, ouvrez Anaconda Navigator ou Jupyter Notebook.

3
 Python

1.1.2 Installation manuelle de Python

Si vous préférez installer Python sans Anaconda :

1. Téléchargez l’installateur depuis https://www.python.org.
2. Installez Python en cochant l’option Add Python to PATH.
3. Vérifiez l’installation en ouvrant un terminal et en tapant :
sh python --version

1.2 Environnements de travail pour l’analyse de données

1.2.1 Jupyter Notebook

Jupyter est un environnement interactif idéal pour l’analyse de données. Il est inclus dans Anaconda
et peut être installé avec la commande :

pip install notebook

Pour le lancer, utilisez :

jupyter notebook

1.2.2 Google Colab

Google Colab est une alternative en ligne qui permet d’exécuter du code Python gratuitement sans
installation. Vous pouvez y accéder via :
https://colab.research.google.com.

1.2.3 Visual Studio Code (VS Code)

VS Code est un éditeur puissant avec des extensions pour Python. Pour l’installer :
1. Téléchargez-le depuis https://code.visualstudio.com.
2. Installez l’extension Python.
3. Configurez un environnement virtuel si nécessaire.

Sènan Elisée AMADE, ISE Page 4

 Python

1.3 Premiers pas avec Python

Testons un premier script Python pour vérifier l’installation :

print("Bienvenue dans l'analyse de données avec Python !")

Si ce script s’exécute sans erreur, votre installation est réussie !

Sènan Elisée AMADE, ISE Page 5

 Python

Sènan Elisée AMADE, ISE Page 6

Chapitre 2 : Manipulation des données
avec Pandas

Pandas est une bibliothèque essentielle en analyse de données avec Python. Elle permet de manipuler,
nettoyer et analyser des données sous forme de tableaux similaires aux feuilles Excel ou aux bases de
données SQL.

2.1 Installation et importation de Pandas

Si Pandas n’est pas encore installé sur votre machine, vous pouvez l’installer avec :

pip install pandas

Ensuite, importons la bibliothèque dans Python :

import pandas as pd

2.2 Création et manipulation de DataFrames

Un DataFrame est la structure de données principale de Pandas, similaire à un tableau Excel ou une
table SQL.

2.2.1 Création d’un DataFrame à partir d’un dictionnaire

7
 Python

import pandas as pd

# Création d'un dictionnaire

data = {
"Nom": ["Alice", "Bob", "Charlie"],
"Âge": [25, 30, 35],
"Ville": ["Paris", "Londres", "New York"]
}

# Conversion en DataFrame
df = pd.DataFrame(data)

# Affichage du DataFrame
print(df)

2.2.2 Importation d’un fichier CSV

Les données sont souvent stockées dans des fichiers CSV. Pandas permet de les charger facilement.

df = pd.read_csv("fichier.csv")
print(df.head()) # Afficher les premières lignes

2.2.3 Exportation d’un DataFrame en CSV

Vous pouvez enregistrer vos données modifiées dans un fichier CSV avec :

df.to_csv("nouveau_fichier.csv", index=False)

Sènan Elisée AMADE, ISE Page 8

 Python

2.3 Sélection et filtrage des données

2.3.1 Sélection de colonnes

On peut extraire une colonne spécifique comme ceci :

ages = df["Âge"]
print(ages)

2.3.2 Filtrage des lignes selon une condition

Sélectionner uniquement les personnes âgées de plus de 30 ans :

df_plus_30 = df[df["Âge"] > 30]

print(df_plus_30)

2.3.3 Sélection de plusieurs colonnes

df_subset = df[["Nom", "Ville"]]

print(df_subset)

2.4 Manipulation des valeurs manquantes

Les données contiennent souvent des valeurs manquantes. Pandas propose plusieurs méthodes pour les
gérer.

2.4.1 Détection des valeurs manquantes

print(df.isnull().sum()) # Compter les valeurs manquantes par colonne

Sènan Elisée AMADE, ISE Page 9

 Python

2.4.2 Suppression des valeurs manquantes

df_cleaned = df.dropna() # Supprime les lignes avec des valeurs manquantes

2.4.3 Remplacement des valeurs manquantes

df_filled = df.fillna("Valeur par défaut")

2.5 Transformation et agrégation des données

2.5.1 Ajout d’une nouvelle colonne

df["Âge en 2030"] = df["Âge"] + 6

print(df)

2.5.2 Groupement des données (GroupBy)

On peut regrouper les données par une colonne et appliquer une fonction d’agrégation.

df_grouped = df.groupby("Ville")["Âge"].mean()
print(df_grouped)

Sènan Elisée AMADE, ISE Page 10

Chapitre 3 : Visualisation des données
avec Matplotlib et Seaborn

L’analyse de données ne se limite pas aux chiffres et aux tableaux. La visualisation des données est
essentielle pour comprendre rapidement les tendances, les relations et les anomalies dans un jeu de
données. Python propose plusieurs bibliothèques pour cela, mais les plus populaires sont Matplotlib
et Seaborn.

3.1 Installation et importation des bibliothèques

Si vous ne les avez pas encore installées, utilisez les commandes suivantes :

pip install matplotlib seaborn

Puis, importez-les dans Python :

import matplotlib.pyplot as plt

import seaborn as sns

3.2 Création de graphiques avec Matplotlib

Matplotlib est une bibliothèque très flexible permettant de créer différents types de graphiques.

11
 Python

3.2.1 Tracer un graphique simple

import numpy as np

x = np.linspace(0, 10, 100)

y = np.sin(x)

plt.plot(x, y, label="sin(x)")
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Graphique de la fonction sin(x)")
plt.legend()
plt.show()

3.2.2 Histogramme

data = np.random.randn(1000)
plt.hist(data, bins=30, color="blue", edgecolor="black", alpha=0.7)
plt.title("Histogramme des valeurs aléatoires")
plt.show()

3.2.3 Diagramme en barres

categories = ["A", "B", "C", "D"]

values = [10, 20, 15, 30]

plt.bar(categories, values, color="green")

plt.title("Diagramme en barres")
plt.show()

Sènan Elisée AMADE, ISE Page 12

 Python

3.3 Visualisation avancée avec Seaborn

Seaborn est construit sur Matplotlib et permet de créer des visualisations plus élégantes et complexes
avec moins de code.

3.3.1 Affichage d’un jeu de données avec Seaborn

Seaborn fonctionne bien avec les DataFrames de Pandas. Voici comment charger un jeu de données
intégré et l’afficher :

df = sns.load_dataset("iris")
print(df.head())

3.3.2 Nuage de points (scatter plot)

sns.scatterplot(data=df, x="sepal_length", y="sepal_width", hue="species")

plt.title("Relation entre longueur et largeur des sépales")
plt.show()

3.3.3 Boîte à moustaches (boxplot)

sns.boxplot(x="species", y="petal_length", data=df)

plt.title("Distribution de la longueur des pétales par espèce")
plt.show()

3.3.4 Carte thermique (heatmap) pour les corrélations

corr_matrix = df.corr()
sns.heatmap(corr_matrix, annot=True, cmap="coolwarm", fmt=".2f")
plt.title("Matrice de corrélation")
plt.show()

Sènan Elisée AMADE, ISE Page 13

 Python

3.4 Personnalisation des graphiques

Seaborn et Matplotlib permettent de personnaliser les graphiques avec différents styles :

sns.set_style("darkgrid") # Choisir un style parmi "white", "dark", "ticks", etc.

plt.figure(figsize=(8, 5)) # Définir la taille du graphique

Sènan Elisée AMADE, ISE Page 14

Chapitre 4 : Nettoyage et préparation des
données

Avant d’effectuer une analyse ou un modèle prédictif, il est essentiel de nettoyer et préparer les données.
Ce processus inclut la gestion des valeurs manquantes, la détection des doublons, le formatage des
colonnes et bien plus encore.

4.1 Chargement et exploration des données

Nous allons utiliser Pandas pour charger un jeu de données et l’explorer.

import pandas as pd

# Chargement du dataset
df = pd.read_csv("data.csv")

# Affichage des premières lignes

print(df.head())

# Affichage des informations générales sur le dataset

print(df.info())

# Statistiques descriptives
print(df.describe())

15
 Python

4.2 Gestion des valeurs manquantes

Les valeurs manquantes peuvent fausser l’analyse et doivent être traitées correctement.

4.2.1 Détection des valeurs manquantes

print(df.isnull().sum()) # Compte le nombre de valeurs manquantes par colonne

4.2.2 Suppression des valeurs manquantes

df_cleaned = df.dropna() # Supprime les lignes avec des valeurs manquantes

4.2.3 Remplacement des valeurs manquantes

On peut remplacer les valeurs manquantes par la moyenne, la médiane ou une valeur fixe.

df["Age"] = df["Age"].fillna(df["Age"].mean()) # Remplacement par la moyenne

df["Sexe"] = df["Sexe"].fillna("Non spécifié") # Remplacement par une valeur fixe

4.3 Gestion des doublons

Les doublons peuvent entraîner des erreurs dans les analyses.

4.3.1 Détection des doublons

print(df.duplicated().sum()) # Nombre de lignes en double

Sènan Elisée AMADE, ISE Page 16

 Python

4.3.2 Suppression des doublons

df = df.drop_duplicates()

4.4 Conversion des types de données

Il est parfois nécessaire de convertir le type de certaines colonnes pour assurer la cohérence des analyses.

4.4.1 Vérification des types de données

print(df.dtypes)

4.4.2 Conversion des types

df["Date"] = pd.to_datetime(df["Date"]) # Conversion en format date

df["Revenu"] = df["Revenu"].astype(float) # Conversion en float

4.5 Normalisation et mise à l’échelle des données

Les algorithmes de Machine Learning sont sensibles à l’échelle des données. Il est donc recommandé
de normaliser ou standardiser certaines variables.

4.5.1 Standardisation (Z-score scaling)

from sklearn.preprocessing import StandardScaler

Sènan Elisée AMADE, ISE Page 17

 Python

scaler = StandardScaler()
df["Revenu_scaled"] = scaler.fit_transform(df[["Revenu"]])

4.5.2 Normalisation (Min-Max scaling)

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
df["Revenu_normalized"] = scaler.fit_transform(df[["Revenu"]])

4.6 Encodage des variables catégoriques

Les modèles d’apprentissage automatique ne fonctionnent qu’avec des valeurs numériques. Il faut donc
convertir les variables catégoriques.

4.6.1 Encodage One-Hot

df = pd.get_dummies(df, columns=["Sexe"], drop_first=True)

4.6.2 Encodage Label Encoding

from sklearn.preprocessing import LabelEncoder

encoder = LabelEncoder()
df["Sexe_encoded"] = encoder.fit_transform(df["Sexe"])

Sènan Elisée AMADE, ISE Page 18

Chapitre 5 : Analyse exploratoire des
données (EDA)

L’analyse exploratoire des données (Exploratory Data Analysis, EDA) est une étape clé
dans tout projet d’analyse. Elle permet de mieux comprendre la structure des données, d’identifier les
tendances, les relations et les éventuelles anomalies avant d’appliquer des modèles statistiques ou de
machine learning.

Dans ce chapitre, nous allons :

- Résumer et visualiser les caractéristiques principales d’un jeu de données.
- Identifier les tendances générales et les corrélations.
- Détecter les valeurs aberrantes et les distributions des variables.

5.1 Chargement du jeu de données et exploration initiale

Avant de commencer l’EDA, nous devons charger et examiner les données.

import pandas as pd

# Chargement du dataset
df = pd.read_csv("data.csv")

# Affichage des premières lignes

print(df.head())

# Résumé général des données

19
 Python

print(df.info())

# Statistiques descriptives
print(df.describe())

5.1.1 Vérification des valeurs uniques

Pour les variables catégoriques, il est important de connaître les valeurs uniques présentes.

print(df["Sexe"].unique()) # Exemple pour une colonne catégorique

print(df["Sexe"].value_counts()) # Comptage des occurrences

5.2 Visualisation des distributions

L’analyse de la distribution des variables permet de mieux comprendre leur comportement.

5.2.1 Histogrammes

Un histogramme est utile pour visualiser la distribution des variables numériques.

import matplotlib.pyplot as plt

df["Age"].hist(bins=20, edgecolor="black")
plt.title("Distribution de l'âge")
plt.xlabel("Âge")
plt.ylabel("Fréquence")
plt.show()

5.2.2 Densité des variables numériques

Une alternative à l’histogramme est la courbe de densité, qui lisse la distribution.

Sènan Elisée AMADE, ISE Page 20

 Python

import seaborn as sns

sns.kdeplot(df["Revenu"], shade=True)
plt.title("Densité du revenu")
plt.show()

5.3 Analyse des relations entre variables

5.3.1 Diagramme de dispersion (scatter plot)

Ce type de graphique permet d’examiner les relations entre deux variables numériques.

sns.scatterplot(x=df["Revenu"], y=df["Dépenses"])
plt.title("Relation entre revenu et dépenses")
plt.show()

5.3.2 Matrice de corrélation

Une matrice de corrélation permet d’identifier les relations linéaires entre variables.

corr_matrix = df.corr()

sns.heatmap(corr_matrix, annot=True, cmap="coolwarm", fmt=".2f")

plt.title("Matrice de corrélation")
plt.show()

5.4 Détection des valeurs aberrantes

Les valeurs aberrantes peuvent fausser l’analyse et doivent être identifiées.

Sènan Elisée AMADE, ISE Page 21

 Python

5.4.1 Boîte à moustaches (boxplot)

Un boxplot permet de repérer les valeurs extrêmes.

sns.boxplot(x=df["Revenu"])
plt.title("Boxplot du revenu")
plt.show()

5.4.2 Méthode IQR (Interquartile Range) pour détecter les valeurs aber-
rantes

On peut également utiliser la méthode IQR pour identifier les valeurs aberrantes :

Q1 = df["Revenu"].quantile(0.25)
Q3 = df["Revenu"].quantile(0.75)
IQR = Q3 - Q1

seuil_inf = Q1 - 1.5 * IQR

seuil_sup = Q3 + 1.5 * IQR

outliers = df[(df["Revenu"] < seuil_inf) | (df["Revenu"] > seuil_sup)]

print(outliers)

5.5 Analyse des variables catégoriques

Pour les variables catégoriques, on utilise souvent des diagrammes en barres et des tableaux croisés.

5.5.1 Diagramme en barres

sns.countplot(x=df["Sexe"])
plt.title("Répartition des sexes")

Sènan Elisée AMADE, ISE Page 22

 Python

plt.show()

5.5.2 Tableau croisé (crosstab)

Un tableau croisé permet de voir la distribution d’une variable en fonction d’une autre.

pd.crosstab(df["Sexe"], df["Statut_Marital"])

5.6 Analyse des tendances et des séries temporelles

Si le jeu de données contient des dates, il est possible d’analyser les tendances temporelles.

df["Date"] = pd.to_datetime(df["Date"]) # Conversion de la colonne en datetime

df.set_index("Date", inplace=True) # Définir la date comme index

df["Revenu"].plot()
plt.title("Évolution du revenu au fil du temps")
plt.show()

5.7 Synthèse de l’EDA et prochaines étapes

L’EDA nous permet de :

- Comprendre la structure des données et détecter les valeurs aberrantes.
- Visualiser les tendances et corrélations entre variables.
- Préparer le jeu de données pour les modèles statistiques et de machine learning.

Sènan Elisée AMADE, ISE Page 23

 Python

Sènan Elisée AMADE, ISE Page 24

Chapitre 6 : Introduction aux statistiques
avec Python

L’analyse de données repose souvent sur des outils statistiques pour résumer, comprendre et interpréter
les données. Ce chapitre introduit les principales statistiques descriptives et inférentielles avec Python.

6.1 Statistiques descriptives

Les statistiques descriptives permettent de résumer un jeu de données à l’aide de mesures de

tendance centrale et de dispersion.

6.1.1 Mesures de tendance centrale

Les mesures les plus courantes sont la moyenne, la médiane et le mode.

import pandas as pd
import numpy as np
from scipy import stats

# Chargement des données

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

# Moyenne
print("Moyenne du revenu :", df["Revenu"].mean())

25
 Python

# Médiane
print("Médiane du revenu :", df["Revenu"].median())

# Mode
print("Mode du revenu :", df["Revenu"].mode()[0])

6.1.2 Mesures de dispersion

Elles permettent d’évaluer la variabilité des données.

# Écart-type
print("Écart-type du revenu :", df["Revenu"].std())

# Variance
print("Variance du revenu :", df["Revenu"].var())

# Étendue (Min et Max)

print("Revenu minimum :", df["Revenu"].min())
print("Revenu maximum :", df["Revenu"].max())

# Intervalle interquartile (IQR)

Q1 = df["Revenu"].quantile(0.25)
Q3 = df["Revenu"].quantile(0.75)
IQR = Q3 - Q1
print("Intervalle interquartile (IQR) :", IQR)

6.1.3 Distribution des données

Un histogramme et une courbe de densité permettent de visualiser la distribution des données.

Sènan Elisée AMADE, ISE Page 26

 Python

import matplotlib.pyplot as plt

import seaborn as sns

sns.histplot(df["Revenu"], bins=20, kde=True)

plt.title("Distribution du revenu")
plt.show()

On peut aussi tester la normalité des données avec le test de Shapiro-Wilk :

from scipy.stats import shapiro

stat, p = shapiro(df["Revenu"].dropna()) # Test de normalité

print("Statistique de test de Shapiro-Wilk :", stat)
print("p-value :", p)

Si p-value < 0.05, alors les données ne suivent pas une loi normale.

6.2 Statistiques inférentielles

Les statistiques inférentielles permettent de tirer des conclusions sur une population à partir d’un
échantillon.

6.2.1 Intervalle de confiance

Un intervalle de confiance estime l’intervalle probable où se trouve la moyenne de la population.

import scipy.stats as stats

mean = df["Revenu"].mean()
std = df["Revenu"].std()
n = len(df["Revenu"])

Sènan Elisée AMADE, ISE Page 27

 Python

# Calcul de l'intervalle de confiance à 95%

interval = stats.norm.interval(0.95, loc=mean, scale=std/np.sqrt(n))
print("Intervalle de confiance à 95% :", interval)

6.2.2 Test de comparaison de moyennes (Test t de Student)

Si l’on veut comparer les revenus moyens entre deux groupes (ex : hommes et femmes), on peut utiliser
un test t de Student.

group1 = df[df["Sexe"] == "Homme"]["Revenu"]

group2 = df[df["Sexe"] == "Femme"]["Revenu"]

t_stat, p_value = stats.ttest_ind(group1, group2, equal_var=False)

print("Statistique de test :", t_stat)
print("p-value :", p_value)

Si p-value < 0.05, on rejette l’hypothèse d’égalité des moyennes.

### 6.2.3 Analyse de la relation entre variables

#### Corrélation de Pearson (relation linéaire entre deux variables continues)
python corr, p_value = stats.pearsonr(df["Revenu"], df["Dépenses"])
print("Corrélation de Pearson :", corr) print("p-value :", p_value)
Si p-value < 0.05, la relation entre les deux variables est significative.
#### Test du Khi-deux (relation entre variables catégoriques)
python contingency_table = pd.crosstab(df["Sexe"], df["Statut_Marital"]) chi2, p,
dof, expected = stats.chi2_contingency(contingency_table) print("Statistique
Khi-deux :", chi2) print("p-value :", p)
Si p-value < 0.05, on rejette l’hypothèse d’indépendance entre les deux variables.

Sènan Elisée AMADE, ISE Page 28

 Python

6.3 Régression linéaire simple

La régression linéaire permet de modéliser la relation entre une variable dépendante (Y ) et une
variable indépendante (X ).

import statsmodels.api as sm

# Définition des variables

X = df["Revenu"]
y = df["Dépenses"]

# Ajout de la constante
X = sm.add_constant(X)

# Ajustement du modèle
model = sm.OLS(y, X).fit()

# Résumé du modèle
print(model.summary())

Si le coefficient de Revenu est significatif (p-value < 0.05 ), alors le Revenu influence significativement
les Dépenses.

6.4 Synthèse et prochaines étapes

Dans ce chapitre, nous avons vu :

- Les statistiques descriptives (moyenne, médiane, écart-type, histogramme. . . ).
- Les statistiques inférentielles (test t, intervalle de confiance, corrélation. . . ).
- Une première approche de la régression linéaire.

Dans le prochain chapitre, nous allons approfondir la modélisation statistique et machine learning
avec Python.

Sènan Elisée AMADE, ISE Page 29

 Python

Sènan Elisée AMADE, ISE Page 30

Chapitre 7 : Modélisation statistique et
machine learning avec Python

Dans ce chapitre, nous allons explorer les bases du machine learning (ML) avec Python, en
commençant par les modèles statistiques classiques, puis en introduisant des modèles d’apprentissage
supervisé.

7.1 Introduction au machine learning

Le machine learning est une branche de l’intelligence artificielle qui permet aux ordinateurs d’apprendre
à partir de données et de faire des prédictions.

On distingue deux types principaux :

- Apprentissage supervisé : l’algorithme apprend à partir d’un ensemble de données étiquetées (ex
: prédire le revenu d’une personne à partir de son âge et de son niveau d’éducation).
- Apprentissage non supervisé : l’algorithme découvre des structures cachées dans les données sans
labels (ex : regrouper les clients en segments selon leurs comportements d’achat).

Dans ce chapitre, nous allons nous concentrer sur l’apprentissage supervisé.

7.2 Préparation des données

Avant d’entraîner un modèle, il est essentiel de nettoyer et préparer les données.

31
 Python

7.2.1 Chargement et exploration des données

import pandas as pd
import numpy as np

# Chargement des données

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

# Afficher les premières lignes

print(df.head())

# Vérifier les valeurs manquantes

print(df.isnull().sum())

# Remplacer les valeurs manquantes par la moyenne

df.fillna(df.mean(), inplace=True)

7.2.2 Séparation des données en ensemble d’entraînement et de test

from sklearn.model_selection import train_test_split

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

X = df[["Age", "Niveau_Education", "Revenu"]]
y = df["Dépenses"]

# Séparation en 80% entraînement et 20% test

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

Sènan Elisée AMADE, ISE Page 32

 Python

7.3 Régression linéaire pour la prédiction

La régression linéaire est utilisée pour prédire une variable continue.

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error, r2_score

# Création du modèle
model = LinearRegression()

# Entraînement
model.fit(X_train, y_train)

# Prédiction sur le test set

y_pred = model.predict(X_test)

# Évaluation du modèle
print("R2 :", r2_score(y_test, y_pred))
print("Erreur quadratique moyenne :", mean_squared_error(y_test, y_pred))

Si le coefficient R2 est proche de 1, cela signifie que le modèle explique bien la variabilité des dépenses
en fonction des variables explicatives.

7.4 Classification avec la régression logistique

Si notre cible est une variable binaire (ex : prédire si un client achètera un produit ou non), on utilise
la régression logistique.

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, classification_report

# Supposons que la cible est binaire (0 = pas d'achat, 1 = achat)

Sènan Elisée AMADE, ISE Page 33

 Python

y_class = df["Achat"]

# Séparation des données

X_train, X_test, y_train, y_test = train_test_split(X, y_class, test_size=0.2, random_state=

# Création et entraînement du modèle

log_model = LogisticRegression()
log_model.fit(X_train, y_train)

# Prédiction
y_pred_class = log_model.predict(X_test)

# Évaluation
print("Précision :", accuracy_score(y_test, y_pred_class))
print(classification_report(y_test, y_pred_class))

Si l’accuracy (précision) est élevée, le modèle fait de bonnes prédictions.

7.5 Arbres de décision et forêts aléatoires

Les arbres de décision sont des modèles plus flexibles qui permettent de capturer des interactions
complexes entre les variables.

from sklearn.tree import DecisionTreeClassifier

# Création du modèle
tree_model = DecisionTreeClassifier(max_depth=5, random_state=42)

# Entraînement
tree_model.fit(X_train, y_train)

Sènan Elisée AMADE, ISE Page 34

 Python

# Prédiction et évaluation
y_pred_tree = tree_model.predict(X_test)
print("Précision de l'arbre de décision :", accuracy_score(y_test, y_pred_tree))

Les forêts aléatoires améliorent ce modèle en combinant plusieurs arbres.

from sklearn.ensemble import RandomForestClassifier

# Création du modèle
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)

# Entraînement
rf_model.fit(X_train, y_train)

# Prédiction et évaluation
y_pred_rf = rf_model.predict(X_test)
print("Précision de la forêt aléatoire :", accuracy_score(y_test, y_pred_rf))

Si la précision du modèle RandomForest est meilleure que celle de l’arbre de décision simple, cela
signifie qu’il généralise mieux aux nouvelles données.

7.6 Réseau de neurones avec Scikit-Learn

Les réseaux de neurones sont une approche avancée du machine learning.

from sklearn.neural_network import MLPClassifier

# Création du modèle de réseau de neurones

mlp = MLPClassifier(hidden_layer_sizes=(50, 25), max_iter=1000, random_state=42)

# Entraînement
mlp.fit(X_train, y_train)

Sènan Elisée AMADE, ISE Page 35

 Python

# Prédiction
y_pred_mlp = mlp.predict(X_test)

# Évaluation
print("Précision du réseau de neurones :", accuracy_score(y_test, y_pred_mlp))

Si la précision du modèle est élevée, cela signifie que l’algorithme a bien appris à partir des données.

7.7 Comparaison des modèles

Nous avons exploré plusieurs modèles. Voici une comparaison :

Modèle Type Avantages Inconvénients

Régression linéaire Prédiction continue Simple et interprétable Faible flexibilité

Régression logistique Classification Facile à comprendre Performances
limitées sur données
complexes
Arbre de décision Classification Facile à visualiser Risque de
sur-apprentissage
Forêt aléatoire Classification Meilleure généralisation Plus lent que l’arbre
simple
Réseau de neurones Classification Performances élevées sur Plus complexe à
grandes données entraîner

7.8 Conclusion et prochaines étapes

Dans ce chapitre, nous avons exploré plusieurs méthodes pour l’analyse de données et la prédiction
avec Python :

Sènan Elisée AMADE, ISE Page 36

 Python

Préparation des données

Régression linéaire et logistique
Arbres de décision et forêts aléatoires
Introduction aux réseaux de neurones

Dans le chapitre suivant, nous allons approfondir l’optimisation des modèles et le tuning des
hyperparamètres pour améliorer les performances.

Sènan Elisée AMADE, ISE Page 37

 Python

Sènan Elisée AMADE, ISE Page 38

Chapitre 8 : Optimisation des modèles et
tuning des hyperparamètres

Dans le chapitre précédent, nous avons exploré plusieurs modèles d’apprentissage supervisé. Cependant,
la performance d’un modèle dépend fortement du choix des hyperparamètres. Dans ce chapitre,
nous allons apprendre à optimiser les modèles en ajustant ces hyperparamètres et en évitant le
sur-apprentissage.

8.1 Qu’est-ce que l’optimisation des hyperparamètres ?

Les hyperparamètres sont des paramètres qui ne sont pas appris directement par le modèle, mais
définis avant l’entraînement. Exemples :
- Profondeur maximale d’un arbre de décision
- Nombre de neurones dans un réseau de neurones
- Taux d’apprentissage dans un modèle de gradient boosting

L’objectif de l’optimisation est de trouver les valeurs optimales pour ces hyperparamètres afin
d’obtenir les meilleures performances possibles.

39
 Python

8.2 Validation croisée pour évaluer un modèle

Avant d’ajuster les hyperparamètres, il est important d’évaluer correctement un modèle en utilisant la
validation croisée.

from sklearn.model_selection import cross_val_score

from sklearn.ensemble import RandomForestClassifier

# Création du modèle
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)

# Validation croisée en 5 plis

scores = cross_val_score(rf_model, X, y_class, cv=5)

# Affichage des scores et de la moyenne

print("Scores de validation croisée :", scores)
print("Moyenne des scores :", scores.mean())

La validation croisée permet d’éviter le sur-apprentissage en évaluant le modèle sur plusieurs

sous-ensembles de données.

8.3 Recherche par grille (Grid Search)

La Grid Search teste systématiquement plusieurs combinaisons d’hyperparamètres et sélectionne la

meilleure.

from sklearn.model_selection import GridSearchCV

# Définition des hyperparamètres à tester

param_grid = {
'n_estimators': [50, 100, 200],
'max_depth': [5, 10, 20],

Sènan Elisée AMADE, ISE Page 40

 Python

'min_samples_split': [2, 5, 10]

}

# Création du modèle et de la recherche par grille

grid_search = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=5, n_jobs

# Entraînement
grid_search.fit(X_train, y_train)

# Affichage des meilleurs paramètres

print("Meilleurs paramètres :", grid_search.best_params_)

# Évaluation du meilleur modèle

best_model = grid_search.best_estimator_
print("Précision du meilleur modèle :", best_model.score(X_test, y_test))

La Grid Search est efficace mais peut être lente si le nombre d’hyperparamètres est trop grand.

8.4 Recherche aléatoire (Random Search)

Plutôt que de tester toutes les combinaisons comme la Grid Search, la Random Search en teste un
sous-ensemble aléatoire, ce qui est souvent plus rapide.

from sklearn.model_selection import RandomizedSearchCV

from scipy.stats import randint

# Définition des hyperparamètres avec distribution aléatoire

param_dist = {
'n_estimators': randint(50, 200),
'max_depth': randint(5, 20),
'min_samples_split': randint(2, 10)

Sènan Elisée AMADE, ISE Page 41

 Python

# Création du modèle et de la recherche aléatoire

random_search = RandomizedSearchCV(RandomForestClassifier(random_state=42), param_distributi
n_iter=10, cv=5, n_jobs=-1, random_state=42)

# Entraînement
random_search.fit(X_train, y_train)

# Affichage des meilleurs paramètres

print("Meilleurs paramètres (Random Search) :", random_search.best_params_)

# Évaluation du meilleur modèle

best_model_random = random_search.best_estimator_
print("Précision du meilleur modèle :", best_model_random.score(X_test, y_test))

La Random Search est souvent plus rapide que la Grid Search, tout en trouvant de bons hyper-
paramètres.

8.5 Optimisation bayésienne avec Optuna

Une approche plus avancée pour optimiser les hyperparamètres est l’optimisation bayésienne avec
Optuna.

import optuna
from sklearn.ensemble import RandomForestClassifier

# Fonction d'optimisation
def objective(trial):
n_estimators = trial.suggest_int("n_estimators", 50, 200)
max_depth = trial.suggest_int("max_depth", 5, 20)

Sènan Elisée AMADE, ISE Page 42

 Python

min_samples_split = trial.suggest_int("min_samples_split", 2, 10)

model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth,

min_samples_split=min_samples_split, random_state=42)
score = cross_val_score(model, X_train, y_train, cv=5).mean()

return score

# Lancer l'optimisation
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=20)

# Meilleurs paramètres
print("Meilleurs paramètres (Optuna) :", study.best_params_)

L’optimisation bayésienne est plus rapide que les méthodes classiques et peut donner de meilleurs
résultats.

8.6 Comparaison des méthodes d’optimisation

Méthode Avantages Inconvénients

Grid Search Recherche exhaustive des paramètres Très lent si beaucoup

d’hyperparamètres
Random Search Plus rapide que Grid Search Peut manquer la
meilleure combinaison
Optimisation bayésienne Plus efficace et rapide Plus complexe à
implémenter

Sènan Elisée AMADE, ISE Page 43

 Python

8.7 Régularisation pour éviter le sur-apprentissage

Certains modèles ont des hyperparamètres de régularisation pour éviter le sur-apprentissage.

8.7.1 Régression Ridge et Lasso

La régularisation permet de réduire la complexité d’un modèle en pénalisant les coefficients trop
élevés.

from sklearn.linear_model import Ridge, Lasso

# Ridge (L2)
ridge = Ridge(alpha=1.0)
ridge.fit(X_train, y_train)
print("Score Ridge :", ridge.score(X_test, y_test))

# Lasso (L1)
lasso = Lasso(alpha=0.1)
lasso.fit(X_train, y_train)
print("Score Lasso :", lasso.score(X_test, y_test))

• Ridge (L2) réduit la taille des coefficients mais les garde tous.

• Lasso (L1) met certains coefficients à zéro, ce qui simplifie le modèle.

8.8 Conclusion et prochaines étapes

Dans ce chapitre, nous avons exploré plusieurs méthodes pour optimiser les hyperparamètres et
éviter le sur-apprentissage :

*Validation croisée**

Sènan Elisée AMADE, ISE Page 44

 Python

*Grid Search et Random Search**

*Optimisation bayésienne avec Optuna**
*Régularisation (Ridge et Lasso)**

Dans le chapitre suivant, nous allons aborder l’interprétation des modèles et l’explicabilité
de l’IA.

Sènan Elisée AMADE, ISE Page 45

 Python

Sènan Elisée AMADE, ISE Page 46

Chapitre 9 : Interprétation et
Explicabilité des modèles de Machine
Learning

Les modèles de machine learning, notamment les modèles complexes comme les forêts aléatoires
ou les réseaux de neurones, sont souvent perçus comme des boîtes noires. Cela signifie que, bien
qu’ils puissent offrir des performances exceptionnelles, il peut être difficile de comprendre comment ils
arrivent à leurs décisions. Dans ce chapitre, nous allons explorer des techniques pour interpréter et
expliquer les prédictions des modèles.

9.1 Pourquoi l’interprétabilité des modèles est-elle importante

?

L’interprétabilité des modèles de machine learning est cruciale pour plusieurs raisons :
- Confiance des utilisateurs : Comprendre pourquoi un modèle prend une certaine décision peut
augmenter la confiance des utilisateurs dans le modèle.
- Conformité aux régulations : Dans certains secteurs (comme la santé ou la finance), les régulations
exigent que les décisions d’un modèle soient expliquées clairement.
- Amélioration du modèle : En interprétant un modèle, on peut mieux comprendre ses erreurs et
ainsi l’améliorer.

47
 Python

9.2 Méthodes d’interprétation des modèles

9.2.1 Importance des caractéristiques avec Random Forest

Les forêts aléatoires sont très populaires en machine learning, et une méthode courante pour interpréter
ces modèles est d’analyser l’importance des caractéristiques. Cela permet de voir quelles variables
sont les plus influentes dans les prédictions.

import matplotlib.pyplot as plt

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

# Chargement des données

data = load_iris()
X, y = data.data, data.target

# Entraînement d'un modèle Random Forest

rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X, y)

# Importance des caractéristiques

importances = rf.feature_importances_

# Visualisation
features = data.feature_names
plt.barh(features, importances)
plt.xlabel("Importance des caractéristiques")
plt.title("Importance des caractéristiques pour le modèle Random Forest")
plt.show()

Les caractéristiques les plus importantes sont celles qui ont le plus grand poids dans la décision
du modèle.

Sènan Elisée AMADE, ISE Page 48

 Python

9.2.2 LIME : Local Interpretable Model-Agnostic Explanations

LIME est une méthode permettant d’expliquer les prédictions d’un modèle pour une observa-
tion spécifique. L’idée est de créer un modèle simple (comme une régression linéaire) qui peut
approximativement reproduire le comportement du modèle complexe pour un exemple particulier.

import lime
from lime.lime_tabular import LimeTabularExplainer
import numpy as np

# Création de l'explainer LIME

explainer = LimeTabularExplainer(X_train, training_labels=y_train, mode="classification", cl

# Sélection d'un exemple pour l'explication

i = 15 # Exemple à expliquer
explanation = explainer.explain_instance(X_test[i], rf.predict_proba, num_features=5)

# Affichage de l'explication
explanation.show_in_notebook()

LIME fournit des explications locales, permettant de comprendre pourquoi une prédiction particulière
a été faite.

9.2.3 SHAP : SHapley Additive exPlanations

Les valeurs SHAP sont une autre approche très populaire pour interpréter les modèles. SHAP
décompose chaque prédiction en une contribution individuelle de chaque caractéristique. Cette
approche est basée sur la théorie des jeux et est très efficace pour comprendre l’impact de chaque
variable sur la prédiction.

import shap

# Création d'un explainer SHAP

Sènan Elisée AMADE, ISE Page 49

 Python

explainer = shap.TreeExplainer(rf)

# Calcul des valeurs SHAP

shap_values = explainer.shap_values(X_test)

# Visualisation des valeurs SHAP pour un exemple spécifique

shap.initjs()
shap.force_plot(shap_values[1][0], X_test[0], features=features)

Les valeurs SHAP sont particulièrement utiles pour obtenir des explications globales (sur l’ensemble
du modèle) et locales (pour chaque prédiction).

9.3 Interprétation des réseaux de neurones avec Grad-CAM

Pour les modèles de réseaux de neurones, en particulier les réseaux convolutifs (CNN) utilisés
pour des tâches comme la reconnaissance d’image, des techniques comme Grad-CAM permettent de
visualiser quelles parties de l’image ont le plus influencé la prédiction du modèle.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Charger un modèle pré-entrainé (par exemple ResNet50)

model = tf.keras.applications.ResNet50(weights='imagenet')

# Charger une image à expliquer

img = tf.keras.preprocessing.image.load_img("image.jpg", target_size=(224, 224))
img_array = tf.keras.preprocessing.image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)

# Obtenir les prédictions

Sènan Elisée AMADE, ISE Page 50

 Python

predictions = model.predict(img_array)

# Appliquer Grad-CAM pour visualiser l'importance des régions

grad_cam = tf.keras.preprocessing.image.load_img("image.jpg", target_size=(224, 224))

plt.imshow(grad_cam)
plt.show()

Grad-CAM met en évidence les régions d’image qui ont le plus contribué à la prédiction d’un réseau
de neurones.

9.4 Conclusion : Interprétabilité et Éthique dans le Machine

Learning

L’interprétabilité est devenue un aspect essentiel du machine learning, en particulier avec l’augmentation
de l’utilisation de modèles complexes. La capacité à expliquer les décisions des modèles assure non
seulement leur fiabilité mais aussi leur acceptation par les utilisateurs.

Dans ce chapitre, nous avons exploré différentes méthodes pour expliquer les décisions des modèles,
qu’il s’agisse de modèles simples comme les forêts aléatoires ou de modèles plus complexes comme les
réseaux de neurones. Ces techniques permettent aux praticiens de mieux comprendre leurs modèles et
de les améliorer en fonction des résultats obtenus.

Le chapitre suivant portera sur les modèles non supervisés et leur utilisation dans des tâches
telles que la segmentation ou la réduction de dimension.

Souhaitez-vous continuer avec ce prochain chapitre ?

Parfait, voici donc le Chapitre 10 : Modèles non supervisés et réduction de dimension.

Sènan Elisée AMADE, ISE Page 51

 Python

Sènan Elisée AMADE, ISE Page 52

Chapitre 10 : Modèles non supervisés et
réduction de dimension

Les modèles non supervisés sont utilisés lorsqu’il n’y a pas de labels ou de résultats prédéfinis
pour les données. L’objectif principal est de découvrir des structures ou des patterns cachés dans les
données. Dans ce chapitre, nous allons explorer deux grandes catégories de modèles non supervisés :
la segmentation (ou clustering) et la réduction de dimension.

10.1 Segmentation (Clustering)

Le clustering est l’une des tâches les plus courantes en apprentissage non supervisé. Il consiste à
regrouper des données similaires en clusters. L’un des algorithmes les plus populaires pour cette
tâche est K-means.

10.1.1 K-means Clustering

L’algorithme K-means cherche à diviser un ensemble de données en K clusters, où chaque observation

appartient au cluster dont la moyenne est la plus proche. Voici un exemple d’implémentation en
Python avec scikit-learn :

from sklearn.cluster import KMeans

import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

53
 Python

# Générer des données simulées

X, y = make_blobs(n_samples=300, centers=4, random_state=42)

# Appliquer K-means
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)

# Affichage des résultats

plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=200, c='red', ma
plt.title("Clustering avec K-means")
plt.show()

Cet algorithme divise les points en quatre clusters et affiche les centres de ces clusters en rouge.

10.1.2 DBSCAN (Density-Based Spatial Clustering of Applications with

Noise)

Une alternative à K-means est DBSCAN, qui est basé sur la densité des points. DBSCAN est utile
lorsqu’on a des clusters de forme arbitraire et qu’il existe du bruit dans les données.

from sklearn.cluster import DBSCAN

# Appliquer DBSCAN
dbscan = DBSCAN(eps=0.3, min_samples=10)
labels = dbscan.fit_predict(X)

# Affichage des résultats

plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.title("Clustering avec DBSCAN")
plt.show()

Sènan Elisée AMADE, ISE Page 54

 Python

DBSCAN est capable de trouver des clusters de forme irrégulière et d’identifier les points
considérés comme du bruit.

10.2 Réduction de dimension

La réduction de dimension est une technique qui consiste à transformer un ensemble de données de
haute dimensionnalité en un ensemble de données de plus faible dimension tout en préservant autant
d’information que possible.

10.2.1 PCA (Principal Component Analysis)

L’analyse en composantes principales (PCA) est une méthode de réduction de dimension qui
cherche à projeter les données sur les axes (composantes principales) qui expliquent la plus grande
variance.

from sklearn.decomposition import PCA

import numpy as np

# Générer des données simulées

X = np.random.rand(100, 5)

# Appliquer PCA pour réduire la dimension à 2

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

# Affichage des résultats

plt.scatter(X_pca[:, 0], X_pca[:, 1])
plt.title("Réduction de dimension avec PCA")
plt.show()

PCA projette les données sur un espace réduit tout en préservant l’essentiel de la variance présente

Sènan Elisée AMADE, ISE Page 55

 Python

dans les données.

10.2.2 t-SNE (t-distributed Stochastic Neighbor Embedding)

Une autre technique de réduction de dimension est t-SNE, qui est particulièrement utile pour la
visualisation de données en 2D ou 3D. Contrairement à PCA, t-SNE conserve mieux les relations
locales entre les points de données.

from sklearn.manifold import TSNE

# Appliquer t-SNE pour réduire la dimension à 2

tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X)

# Affichage des résultats

plt.scatter(X_tsne[:, 0], X_tsne[:, 1])
plt.title("Réduction de dimension avec t-SNE")
plt.show()

t-SNE est particulièrement utile lorsque vous voulez visualiser des structures complexes dans des
ensembles de données de très haute dimension.

10.3 Conclusion : L’importance de l’apprentissage non super-

visé

Les modèles non supervisés sont extrêmement puissants lorsqu’il s’agit de découvrir des patterns
dans des données non étiquetées. Que ce soit pour la segmentation des données ou la réduction
de dimension, ces techniques offrent une grande flexibilité et permettent d’explorer de manière
approfondie les structures cachées dans vos données.

Sènan Elisée AMADE, ISE Page 56

 Python

Dans ce chapitre, nous avons couvert des techniques essentielles telles que K-means, DBSCAN,
PCA, et t-SNE, qui vous aideront à analyser vos données de manière plus précise et à mieux
comprendre leurs structures sous-jacentes.

Le chapitre suivant explorera les modèles de deep learning et leur application dans des tâches
complexes telles que la reconnaissance d’image et le traitement du langage naturel.

Sènan Elisée AMADE, ISE Page 57

 Python

Sènan Elisée AMADE, ISE Page 58

Chapitre 12 : Méthodes Avancées
d’Optimisation

L’optimisation est un processus fondamental dans l’entraînement des modèles d’apprentissage automa-
tique. L’objectif est d’ajuster les paramètres du modèle (comme les poids dans un réseau neuronal)
afin de minimiser la fonction de coût (ou de perte). Si l’optimisation n’est pas bien effectuée, le modèle
peut ne pas converger vers une solution optimale. Dans ce chapitre, nous aborderons des techniques
avancées d’optimisation, telles que la descente de gradient stochastique (SGD) et ses variantes,
ainsi que des méthodes plus sophistiquées comme Adam, RMSprop et Adagrad.

12.1 Descente de Gradient Stochastique (SGD)

La descente de gradient est l’un des algorithmes d’optimisation les plus utilisés. Elle cherche à
minimiser une fonction de coût en ajustant les paramètres du modèle dans la direction opposée au
gradient de la fonction de perte par rapport aux paramètres.

12.1.1 Description de la Méthode

L’algorithme de base est le suivant :

1. Choisir un point de départ (initialiser les paramètres).

2. Calculer le gradient de la fonction de coût par rapport aux paramètres.
3. Mettre à jour les paramètres dans la direction opposée au gradient, à l’aide d’un taux
d’apprentissage défini.

59
 Python

4. Répéter l’étape 2 jusqu’à ce que la fonction de coût converge (atteigne un minimum).

La descente de gradient stochastique (SGD) est une variante de cette méthode, où au lieu de
calculer le gradient sur l’ensemble de l’ensemble de données, nous l’estimons sur un échantillon aléatoire
(mini-lot).

12.2 Variantes de la Descente de Gradient

12.2.1 Adam (Adaptive Moment Estimation)

Adam combine les avantages de deux autres extensions populaires : Momentum et RMSprop. Ce
procédé calcule les moyennes mobiles des gradients (premiers moments) et des carrés des gradients
(deuxièmes moments), et adapte le taux d’apprentissage pour chaque paramètre.

L’algorithme Adam est défini comme suit :

1. Moyenne des gradients (m) et moyenne des carrés des gradients (v) sont calculées pour
chaque paramètre.
2. Un taux d’apprentissage adaptatif est appliqué pour ajuster chaque paramètre en fonction de
l’historique des gradients.

Le pseudocode d’Adam est le suivant :

# Initialisation
m = 0 # Premier moment
v = 0 # Deuxième moment
t = 0 # Compteur d'itérations
alpha = 0.001 # Taux d'apprentissage
beta1 = 0.9 # Taux de décroissance du premier moment
beta2 = 0.999 # Taux de décroissance du deuxième moment

# Boucle d'optimisation
for t in range(1, T+1):
g_t = gradient_of_loss_function(t) # Calculer le gradient

Sènan Elisée AMADE, ISE Page 60

 Python

m = beta1 * m + (1 - beta1) * g_t # Mise à jour du premier moment

v = beta2 * v + (1 - beta2) * g_t**2 # Mise à jour du deuxième moment
m_hat = m / (1 - beta1**t) # Correction du biais pour le premier moment
v_hat = v / (1 - beta2**t) # Correction du biais pour le deuxième moment
theta_t = theta_t - alpha * m_hat / (sqrt(v_hat) + epsilon) # Mise à jour des paramètre

Avantages : Adam ajuste dynamiquement le taux d’apprentissage pour chaque paramètre, ce qui
lui permet de mieux gérer les situations où certains paramètres doivent évoluer plus rapidement que
d’autres.

12.2.2 RMSprop

RMSprop est une autre méthode d’optimisation qui adapte le taux d’apprentissage pour chaque
paramètre en utilisant une moyenne mobile des carrés des gradients.

12.2.2.1 Description de RMSprop

Dans RMSprop, le taux d’apprentissage est ajusté en fonction du gradient moyen des dernières étapes :

# Initialisation
g_t = gradient_of_loss_function(t) # Calcul du gradient
cache_t = decay_rate * cache_t + (1 - decay_rate) * g_t**2 # Moyenne mobile des carrés des
theta_t = theta_t - alpha * g_t / (sqrt(cache_t) + epsilon) # Mise à jour des paramètres

Avantages : RMSprop aide à ajuster le taux d’apprentissage pour chaque paramètre, ce qui peut
améliorer la convergence pour les modèles qui rencontrent des gradients explosifs ou très volatils.

12.2.3 Adagrad

Adagrad est une méthode d’optimisation qui adapte le taux d’apprentissage en fonction de l’historique
des gradients. Elle ajuste les taux d’apprentissage pour chaque paramètre en fonction de la somme

Sènan Elisée AMADE, ISE Page 61

 Python

cumulée des carrés des gradients, permettant aux paramètres moins fréquemment mis à jour d’évoluer
plus rapidement.

12.2.3.1 Description d’Adagrad

L’algorithme Adagrad est formulé comme suit :

# Initialisation
cache_t = 0 # Somme cumulée des carrés des gradients

# Boucle d'optimisation
for t in range(1, T+1):
g_t = gradient_of_loss_function(t) # Calcul du gradient
cache_t += g_t**2 # Somme des carrés des gradients
theta_t = theta_t - alpha * g_t / (sqrt(cache_t) + epsilon) # Mise à jour des paramètre

Avantages : Adagrad est particulièrement utile pour les modèles où certains paramètres sont plus
rares ou moins fréquemment mis à jour.

12.3 Conclusion

Les méthodes avancées d’optimisation telles que Adam, RMSprop, et Adagrad jouent un rôle crucial
dans l’amélioration des performances des modèles d’apprentissage automatique. Ces techniques perme-
ttent de surmonter les limitations de la descente de gradient classique en adaptant dynamiquement les
taux d’apprentissage pour chaque paramètre du modèle. En choisissant l’algorithme d’optimisation ap-
proprié, vous pouvez accélérer la convergence et améliorer les résultats de vos modèles, particulièrement
dans les cas de deep learning.

Le chapitre suivant explorera les méthodes de régularisation pour éviter le surapprentissage et

améliorer la généralisation des modèles.

Sènan Elisée AMADE, ISE Page 62

 Python

Sènan Elisée AMADE, ISE Page 63

 Python

Sènan Elisée AMADE, ISE Page 64

Chapitre 13 : Régularisation dans
l’Apprentissage Automatique

L’un des défis majeurs de l’apprentissage automatique est le surapprentissage, ou overfitting, où

le modèle apprend trop bien les données d’entraînement, mais échoue à généraliser sur de nouvelles
données. La régularisation est une technique cruciale pour éviter ce phénomène en ajoutant des
contraintes ou des pénalités supplémentaires au modèle. Dans ce chapitre, nous aborderons les
différentes méthodes de régularisation, comme L1, L2, et Dropout, qui aident à améliorer la capacité
de généralisation des modèles.

13.1 Qu’est-ce que la Régularisation ?

La régularisation consiste à ajouter un terme supplémentaire à la fonction de perte pour limiter la

complexité du modèle. Ce terme de régularisation pénalise les solutions qui sont trop complexes ou
qui ajustent trop finement les données d’entraînement, ce qui peut conduire à un surapprentissage.

La régularisation peut être utilisée pour :

1. Réduire l’impact des caractéristiques peu importantes (en les contraignant à des valeurs proches
de zéro).
2. Empêcher le modèle de devenir trop complexe (par exemple, en limitant la taille des poids dans
les réseaux neuronaux).
3. Améliorer la généralisation du modèle à de nouvelles données.

65
 Python

13.2 La Régularisation L1 (Lasso)

La régularisation L1, également appelée Lasso (Least Absolute Shrinkage and Selection Operator),
ajoute une pénalité basée sur la somme des valeurs absolues des coefficients du modèle. Cela encourage
le modèle à réduire certains coefficients à zéro, ce qui peut être utilisé comme une forme de sélection
de caractéristiques.

13.2.1 Formulation

La fonction de perte avec la régularisation L1 est :

n
X
L(θ) = L0 (θ) + λ |θi |
i=1

Où : - L0 (θ) est la fonction de perte originale (par exemple, l’erreur quadratique). - λ est le coefficient
de régularisation, qui contrôle la force de la pénalité. - θi sont les coefficients du modèle.

La régularisation L1 permet une sparse solution, où certaines caractéristiques peuvent être complète-
ment éliminées du modèle.

13.2.2 Avantages de L1

• Sélection automatique de caractéristiques : L1 pousse certains coefficients à zéro, ce qui

peut être utilisé pour sélectionner automatiquement les variables les plus pertinentes.
• Simplicité : Parfois, une solution plus simple avec moins de variables peut être préférable,
particulièrement lorsqu’il y a beaucoup de caractéristiques.

Sènan Elisée AMADE, ISE Page 66

 Python

13.3 La Régularisation L2 (Ridge)

La régularisation L2, aussi connue sous le nom de Ridge ou Tikhonov regularization, ajoute une
pénalité basée sur la somme des carrés des coefficients du modèle. Contrairement à L1, elle n’élimine
pas complètement les coefficients mais les réduit progressivement.

13.3.1 Formulation

La fonction de perte avec la régularisation L2 est :

n
θi2
X
L(θ) = L0 (θ) + λ
i=1

Où : - L0 (θ) est la fonction de perte originale. - λ est le coefficient de régularisation. - θi sont les
coefficients du modèle.

La régularisation L2 réduit l’impact de certaines caractéristiques, mais elles ne sont jamais complètement
supprimées.

13.3.2 Avantages de L2

• Réduction de l’impact des valeurs extrêmes : L2 empêche certains paramètres d’être trop
grands, ce qui peut améliorer la stabilité du modèle.
• Moins de variance : L2 aide à mieux contrôler la variance du modèle, ce qui peut être
particulièrement utile lorsque vous avez beaucoup de données avec une forte dimensionnalité.

13.4 La Régularisation ElasticNet

L’ElasticNet combine les avantages de L1 et L2. Elle est utile lorsque vous avez beaucoup de
caractéristiques corrélées. ElasticNet utilise une combinaison linéaire des pénalités L1 et L2.

Sènan Elisée AMADE, ISE Page 67

 Python

13.4.1 Formulation

La fonction de perte avec la régularisation ElasticNet est :

n n
θi2
X X
L(θ) = L0 (θ) + λ1 |θi | + λ2
i=1 i=1

Où : - λ1 et λ2 sont les coefficients de régularisation pour L1 et L2 respectivement.

ElasticNet est particulièrement utile dans les cas où vous avez des groupes de variables fortement
corrélées.

13.5 Dropout dans les Réseaux Neuronaux

Dropout est une technique de régularisation spécifique aux réseaux neuronaux. Pendant l’entraînement,
un certain pourcentage des neurones est “désactivé” de manière aléatoire. Cela empêche les neurones
de devenir trop dépendants les uns des autres et améliore la généralisation du modèle.

13.5.1 Fonctionnement du Dropout

Lors de chaque itération d’entraînement, un sous-ensemble de neurones est mis à zéro. Par exemple,
si un taux de dropout de 0.5 est utilisé, cela signifie qu’à chaque étape d’entraînement, 50 % des
neurones de la couche seront ignorés.

13.5.2 Avantages du Dropout

• Éviter le surapprentissage : Le dropout empêche le modèle de devenir trop complexe et de

sur-apprendre les données d’entraînement.
• Réduction du surapprentissage sur des données bruyantes : Le fait de “désactiver”
aléatoirement certaines connexions pendant l’entraînement rend le modèle plus robuste aux
données bruyantes.

Sènan Elisée AMADE, ISE Page 68

 Python

13.6 Conclusion

La régularisation est une composante clé pour améliorer la généralisation des modèles d’apprentissage
automatique. Les méthodes comme L1, L2, ElasticNet et Dropout aident à éviter le surapprentissage
en imposant des contraintes sur les paramètres du modèle. En ajustant correctement les coefficients de
régularisation, vous pouvez améliorer la robustesse de vos modèles et mieux les préparer à prédire de
nouvelles données.

Le chapitre suivant traitera de la validation croisée et des techniques d’évaluation des mod-
èles pour mieux mesurer la performance des modèles sur des ensembles de test.

Sènan Elisée AMADE, ISE Page 69

 Python

Sènan Elisée AMADE, ISE Page 70

Chapitre 14 : Validation Croisée et
Évaluation des Modèles

La validation croisée et l’évaluation des modèles sont des étapes essentielles pour comprendre la
performance de vos modèles d’apprentissage automatique. Ces techniques permettent de s’assurer
que le modèle généralise bien aux données invisibles et qu’il n’est pas trop ajusté aux données
d’entraînement (surapprentissage). Dans ce chapitre, nous allons explorer les méthodes courantes de
validation croisée et d’évaluation, en mettant l’accent sur la validation croisée k-fold, la validation
croisée Leave-One-Out (LOO), et les mesures de performance telles que la précision, le rappel, et
la F-mesure.

14.1 Qu’est-ce que la Validation Croisée ?

La validation croisée est une méthode qui permet d’évaluer la performance d’un modèle sur des
données non utilisées pendant l’entraînement. Cela consiste à diviser l’ensemble des données en
plusieurs sous-ensembles (ou “folds”), puis à entraîner et tester le modèle sur ces sous-ensembles de
manière itérative. L’objectif est de s’assurer que le modèle peut bien généraliser à des données nouvelles
et non observées.

La validation croisée est utilisée pour : 1. Estimer la performance d’un modèle. 2. Ajuster les
hyperparamètres du modèle. 3. Prévenir le surapprentissage en testant le modèle sur des données
différentes à chaque itération.

71
 Python

14.2 Validation Croisée k-fold

La validation croisée k-fold est l’une des méthodes les plus couramment utilisées. Elle consiste à
diviser les données en k sous-ensembles (ou “folds”) égaux. Le modèle est ensuite entraîné sur k-1
de ces sous-ensembles, et testé sur le k-ième sous-ensemble. Ce processus est répété k fois, chaque
sous-ensemble servant à la fois de données d’entraînement et de données de test.

14.2.1 Étapes de la Validation Croisée k-fold

1. Divisez l’ensemble de données en k parties égales.

2. Pour chaque itération :
• Utilisez k-1 parties pour entraîner le modèle.
• Testez le modèle sur la partie restante.
3. Calculez la performance moyenne du modèle sur les k itérations.

14.2.2 Avantages de k-fold

• Estimation plus fiable : En moyenne, chaque point de donnée est utilisé pour l’entraînement
et pour le test, ce qui donne une estimation plus stable de la performance du modèle.
• Moins de biais : Comme chaque sous-ensemble est utilisé pour les tests, le modèle est testé
sur différentes partitions des données, ce qui permet de mieux évaluer sa capacité à généraliser.

14.3 Validation Croisée Leave-One-Out (LOO)

La validation croisée Leave-One-Out (LOO) est une forme extrême de validation croisée où
chaque point de donnée est utilisé à son tour comme ensemble de test, et le reste des données comme
ensemble d’entraînement. Autrement dit, si vous avez n échantillons de données, le modèle est entraîné
n fois, chaque fois en laissant de côté un échantillon comme test.

Sènan Elisée AMADE, ISE Page 72

 Python

14.3.1 Avantages et inconvénients

• Avantages :
– La validation LOO peut être très utile lorsque vous avez un petit ensemble de données, car
chaque point de donnée est utilisé pour tester le modèle.
• Inconvénients :
– C’est une méthode coûteuse en termes de temps de calcul, car elle nécessite n itérations
d’entraînement.
– Elle peut conduire à une forte variance dans l’estimation de la performance si le modèle est
très sensible à un échantillon spécifique.

14.4 Évaluation de la Performance du Modèle

Une fois que nous avons effectué une validation croisée, il est important de quantifier la performance
du modèle. Différentes métriques d’évaluation permettent de mesurer cette performance, en fonction
du type de problème (classification, régression, etc.). Voici quelques mesures couramment utilisées
pour évaluer les modèles de classification.

14.4.1 Précision (Accuracy)

La précision est la proportion des prédictions correctes parmi toutes les prédictions effectuées. Elle
est utilisée pour évaluer les modèles de classification binaire ou multiclass.

Vrais Positifs + Vrais Négatifs

Précision =
Total des prédictions

14.4.2 Précision et Rappel

• Précision (Precision) : C’est la proportion des prédictions positives qui sont réellement
positives. C’est une mesure de la fiabilité des prédictions positives du modèle.

Sènan Elisée AMADE, ISE Page 73

 Python

Vrais Positifs
Précision =
Vrais Positifs + Faux Positifs
• Rappel (Recall) : C’est la proportion des éléments positifs qui ont été correctement identifiés
par le modèle. C’est une mesure de la completude des prédictions positives.

Vrais Positifs
Rappel =
Vrais Positifs + Faux Négatifs

14.4.3 F-mesure

La F-mesure est une combinaison de la précision et du rappel. Elle est particulièrement utile lorsque
les classes sont déséquilibrées. Elle est définie comme la moyenne harmonique de la précision et du
rappel.

Précision × Rappel
F-mesure = 2 ×
Précision + Rappel

14.4.4 Matrice de Confusion

Une matrice de confusion est un outil qui permet de visualiser la performance d’un modèle de
classification. Elle montre les vrais positifs, faux positifs, vrais négatifs et faux négatifs, permettant de
mieux comprendre les erreurs du modèle.

14.5 Validation sur des Données Non Étiquetées

Dans certains cas, les données de test peuvent ne pas être étiquetées. Dans ce cas, des méthodes
comme l’évaluation par la validation croisée ou l’évaluation par un ensemble de validation
indépendant peuvent être utilisées pour évaluer les modèles, même en l’absence de labels.

Sènan Elisée AMADE, ISE Page 74

 Python

14.6 Conclusion

La validation croisée et l’évaluation des modèles sont des étapes cruciales pour garantir que vos modèles
d’apprentissage automatique sont robustes et capables de bien généraliser. La validation croisée
k-fold, la validation croisée LOO, ainsi que les mesures de performance comme la précision, le
rappel, et la F-mesure permettent d’évaluer correctement les performances des modèles. En choisissant
les bonnes techniques de validation et les bonnes métriques d’évaluation, vous pouvez vous assurer que
votre modèle est performant et prêt à faire face à des données réelles.

Le chapitre suivant abordera les réseaux neuronaux profonds et les techniques avancées
d’apprentissage supervisé. Souhaitez-vous poursuivre avec ce chapitre ?

Voici le Chapitre 15 : Réseaux Neuronaux Profonds (Deep Learning) et Techniques

Avancées d’Apprentissage Supervisé.

Sènan Elisée AMADE, ISE Page 75

 Python

Sènan Elisée AMADE, ISE Page 76

Chapitre 15 : Réseaux Neuronaux
Profonds et Techniques Avancées
d’Apprentissage Supervisé

Le Deep Learning, ou apprentissage profond, est une sous-catégorie de l’apprentissage supervisé

qui utilise des réseaux neuronaux pour résoudre des problèmes complexes. Cette approche a connu
une croissance rapide ces dernières années grâce à l’augmentation des données disponibles et à la
puissance de calcul accrue. Dans ce chapitre, nous allons explorer les réseaux neuronaux profonds
et d’autres techniques avancées de l’apprentissage supervisé. Nous verrons comment ces modèles
peuvent être utilisés pour des tâches telles que la classification, la régression, la reconnaissance d’images
et le traitement du langage naturel.

15.1 Introduction aux Réseaux Neuronaux Profonds

Un réseau neuronal profond (ou Deep Neural Network, DNN) est un modèle d’apprentissage
supervisé inspiré du fonctionnement du cerveau humain. Un réseau neuronal est composé de plusieurs
couches de neurones (également appelées couches cachées), d’où le terme “profond”. Ces modèles
sont capables d’apprendre des représentations complexes et abstraites des données, ce qui les rend
particulièrement puissants pour des tâches difficiles.

77
 Python

15.1.1 Composants d’un Réseau Neuronal

1. Neurones : Les unités de traitement de base dans un réseau neuronal. Chaque neurone reçoit
des entrées, les transforme à l’aide d’une fonction d’activation et produit une sortie.
2. Couches : Un réseau neuronal est constitué de plusieurs couches :
• Couche d’entrée : Reçoit les données.
• Couches cachées : Apprennent les représentations des données.
• Couche de sortie : Produit les prédictions du modèle.
3. Poids et biais : Les poids déterminent l’importance des connexions entre les neurones, tandis
que les biais permettent de décaler les sorties des neurones.

15.2 Entraînement d’un Réseau Neuronal Profond

L’entraînement d’un réseau neuronal consiste à ajuster les poids et les biais pour minimiser l’erreur
du modèle. Cela se fait généralement à l’aide d’un algorithme d’optimisation tel que la descente de
gradient. Voici les étapes principales de l’entraînement d’un réseau neuronal :

1. Propagation avant (Forward Propagation) : Les entrées sont passées à travers les couches
du réseau pour produire une prédiction.
2. Calcul de la perte : La différence entre la prédiction du modèle et la valeur réelle est calculée
à l’aide d’une fonction de perte.
3. Rétropropagation (Backpropagation) : L’erreur est propagée en arrière à travers le réseau
pour ajuster les poids et les biais.
4. Mise à jour des poids : Les poids sont mis à jour pour minimiser l’erreur à chaque itération.

15.3 Types de Réseaux Neuronaux Profonds

Il existe plusieurs types de réseaux neuronaux profonds adaptés à des types de données ou des tâches
spécifiques.

Sènan Elisée AMADE, ISE Page 78

 Python

15.3.1 Réseaux de Neurones Convolutifs (CNN)

Les réseaux de neurones convolutifs sont particulièrement utilisés pour les tâches de reconnaissance
d’images. Ces réseaux appliquent des opérations de convolution sur les images, permettant
d’extraire automatiquement des caractéristiques telles que les bords, les textures, et les formes. Les
CNN sont composés de couches de convolution, de couches de pooling et de couches entièrement
connectées.

• Couches de Convolution : Appliquent un filtre à l’image pour extraire des caractéristiques.

• Couches de Pooling : Réduisent la taille des représentations pour diminuer la complexité
computationnelle.
• Couches Entièrement Connectées : Permettent de classifier les données extraites par les
couches précédentes.

15.3.2 Réseaux de Neurones Récurrents (RNN)

Les réseaux neuronaux récurrents sont utilisés pour traiter des données séquentielles, telles que le
texte, la parole ou les séries temporelles. Contrairement aux réseaux neuronaux classiques, les RNN
ont des connexions qui permettent aux informations de se propager à travers le temps, ce qui leur
permet de “mémoriser” des informations précédentes.

Les Long Short-Term Memory (LSTM) et les Gated Recurrent Units (GRU) sont des
variantes des RNN qui permettent de mieux gérer les dépendances à long terme.

15.4 Techniques Avancées d’Apprentissage Supervisé

Outre les réseaux neuronaux profonds, il existe d’autres techniques avancées d’apprentissage supervisé
qui peuvent être utiles pour certaines tâches.

Sènan Elisée AMADE, ISE Page 79

 Python

15.4.1 Machines à Vecteurs de Support (SVM)

Les machines à vecteurs de support sont des modèles puissants pour la classification binaire. Elles
cherchent à trouver l’hyperplan qui sépare les classes de manière optimale. Les SVM peuvent être
utilisés pour des tâches complexes comme la classification de texte, de données biométriques, et la
reconnaissance d’images.

15.4.2 Forêts Aléatoires (Random Forests)

Les forêts aléatoires sont des ensembles de nombreux arbres de décision. Chaque arbre est construit
sur un sous-ensemble aléatoire des données, et la prédiction finale est obtenue en combinant les
prédictions de chaque arbre. Cette approche permet de réduire le risque de surapprentissage et
d’améliorer la robustesse du modèle.

15.4.3 Boosting (Gradient Boosting, XGBoost, LightGBM)

Le boosting est une technique qui combine plusieurs modèles faibles pour créer un modèle puissant.
Les modèles sont construits de manière séquentielle, chaque modèle suivant le précédent pour corriger
ses erreurs. Des algorithmes populaires de boosting incluent Gradient Boosting, XGBoost et
LightGBM, qui ont fait leurs preuves dans des compétitions de data science.

15.5 Conclusion

Les réseaux neuronaux profonds et les techniques avancées d’apprentissage supervisé offrent
des capacités exceptionnelles pour résoudre des problèmes complexes dans divers domaines tels que
la vision par ordinateur, le traitement du langage naturel, et la reconnaissance vocale. Ces modèles
sont capables de traiter de grandes quantités de données et d’extraire des caractéristiques de manière
autonome, ce qui les rend extrêmement puissants.

Dans ce chapitre, nous avons exploré les réseaux neuronaux profonds, les CNN, les RNN, et des
techniques comme les SVM, les forêts aléatoires et le boosting. La compréhension et l’utilisation

Sènan Elisée AMADE, ISE Page 80

 Python

appropriée de ces techniques permettent de résoudre des problèmes d’apprentissage supervisé à un

niveau avancé et de mieux exploiter les données.

Le chapitre suivant se concentrera sur les méthodes d’optimisation pour l’apprentissage

automatique, y compris l’optimisation des hyperparamètres et les algorithmes avancés tels que
l’optimisation bayésienne et l’algorithme génétique. Souhaitez-vous continuer avec ce chapitre
?

Sènan Elisée AMADE, ISE Page 81

 Python

Sènan Elisée AMADE, ISE Page 82

Chapitre 16 : Méthodes d’Optimisation
pour l’Apprentissage Automatique

L’optimisation est un aspect essentiel de l’apprentissage automatique. Les modèles d’apprentissage

nécessitent souvent un ajustement minutieux de leurs paramètres (appelés hyperparamètres)
pour atteindre des performances optimales. Dans ce chapitre, nous explorerons plusieurs méth-
odes d’optimisation qui aident à améliorer les modèles d’apprentissage automatique, notamment
l’optimisation des hyperparamètres, l’optimisation bayésienne, et l’algorithme génétique.

16.1 Introduction à l’Optimisation dans l’Apprentissage Au-

tomatique

L’optimisation dans le contexte de l’apprentissage automatique vise à ajuster les paramètres d’un
modèle pour minimiser une fonction de perte ou maximiser une fonction de performance. Cela peut
inclure des paramètres comme les poids dans un réseau neuronal ou des hyperparamètres comme le
taux d’apprentissage, la taille des lots (batch size), et la profondeur des arbres dans les forêts aléatoires.

Les méthodes d’optimisation peuvent être classées en deux grandes catégories :

1. Optimisation de paramètres internes : Ajustement des poids et biais des modèles pendant
l’entraînement.
2. Optimisation des hyperparamètres : Recherche du meilleur ensemble d’hyperparamètres
avant l’entraînement.

Nous allons nous concentrer sur les techniques d’optimisation des hyperparamètres.

83
 Python

16.2 Recherche sur la Grille (Grid Search)

La recherche sur la grille est l’une des méthodes les plus simples et les plus populaires pour optimiser
les hyperparamètres d’un modèle. Elle consiste à définir un ensemble de valeurs possibles pour
chaque hyperparamètre et à tester toutes les combinaisons possibles pour déterminer la meilleure.

Avantages :

• Simplicité d’implémentation.
• Exhaustivité (explore toutes les combinaisons possibles).

Inconvénients :

• Computationnellement coûteux, surtout avec un grand nombre d’hyperparamètres.

• Risque de surajustement si le nombre d’options est trop grand.

Exemple avec scikit-learn :

from sklearn.model_selection import GridSearchCV

from sklearn.svm import SVC

# Définir les paramètres à tester

param_grid = {
'C': [0.1, 1, 10],
'kernel': ['linear', 'rbf'],
'gamma': ['scale', 'auto']
}

# Créer le modèle

Sènan Elisée AMADE, ISE Page 84

 Python

model = SVC()

# Appliquer la recherche sur la grille

grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X_train, y_train)

# Meilleurs paramètres
print("Meilleurs paramètres : ", grid_search.best_params_)

16.3 Recherche aléatoire (Random Search)

La recherche aléatoire est une méthode d’optimisation plus efficace que la recherche sur la grille.
Plutôt que de tester toutes les combinaisons possibles, elle sélectionne au hasard un sous-ensemble
de combinaisons d’hyperparamètres. Cela permet de réduire le temps de calcul tout en couvrant une
large gamme de valeurs.

Avantages :

• Plus rapide que la recherche sur la grille.

• Peut explorer une plus grande variété de combinaisons.

Inconvénients :

• Moins exhaustif, car il n’explore pas toutes les combinaisons possibles.

Exemple avec scikit-learn :

from sklearn.model_selection import RandomizedSearchCV

from sklearn.svm import SVC

Sènan Elisée AMADE, ISE Page 85

 Python

from scipy.stats import uniform

# Définir les paramètres à tester

param_dist = {
'C': uniform(0.1, 10),
'kernel': ['linear', 'rbf'],
'gamma': ['scale', 'auto']
}

# Créer le modèle
model = SVC()

# Appliquer la recherche aléatoire

random_search = RandomizedSearchCV(model, param_dist, n_iter=100, cv=5)
random_search.fit(X_train, y_train)

# Meilleurs paramètres
print("Meilleurs paramètres : ", random_search.best_params_)

16.4 Optimisation Bayésienne

L’optimisation bayésienne est une méthode plus sophistiquée qui cherche à optimiser une fonction de
manière plus intelligente. Plutôt que de tester toutes les combinaisons d’hyperparamètres comme dans
la recherche sur la grille, elle construit un modèle probabiliste (souvent un modèle gaussien) de la
fonction de perte et sélectionne ensuite les hyperparamètres les plus prometteurs à tester en fonction
de ce modèle.

Avantages :

• Moins coûteux que la recherche sur la grille ou aléatoire.

Sènan Elisée AMADE, ISE Page 86

 Python

• Efficace pour les problèmes avec un grand nombre d’hyperparamètres.

Inconvénients :

• Nécessite plus de connaissances pour bien paramétrer l’algorithme.

• Plus complexe à implémenter que les autres méthodes.

Exemple avec scikit-optimize :

from skopt import BayesSearchCV

from sklearn.svm import SVC

# Définir les paramètres à tester

param_space = {
'C': (0.1, 10.0, 'uniform'),
'kernel': ['linear', 'rbf'],
'gamma': ['scale', 'auto']
}

# Créer le modèle
model = SVC()

# Appliquer l'optimisation bayésienne

opt_search = BayesSearchCV(model, param_space, n_iter=50, cv=5)
opt_search.fit(X_train, y_train)

# Meilleurs paramètres
print("Meilleurs paramètres : ", opt_search.best_params_)

Sènan Elisée AMADE, ISE Page 87

 Python

16.5 Algorithme Génétique pour l’Optimisation

Les algorithmes génétiques sont inspirés de l’évolution naturelle et utilisent des mécanismes tels
que la sélection naturelle, le croisement (crossover), et la mutation pour chercher la solution optimale.
Ils sont souvent utilisés pour optimiser des modèles complexes ou des hyperparamètres difficiles à
optimiser par des méthodes classiques.

Avantages :

• Capacité à explorer une large solution d’espace.

• Adaptabilité aux problèmes d’optimisation complexes.

Inconvénients :

• Plus lents à converger que d’autres méthodes.

• Nécessitent souvent une configuration et des ajustements spécifiques.

Exemple avec deap :

from deap import base, creator, tools, algorithms

import random

# Définir le problème d'optimisation

def eval_function(individual):
# Exemple d'une fonction de perte à minimiser (à ajuster en fonction du problème)
return sum(individual),

# Création de l'environnement génétique

creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin)

toolbox = base.Toolbox()

Sènan Elisée AMADE, ISE Page 88

 Python

toolbox.register("attr_float", random.uniform, 0, 10)

toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=1
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1.0, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", eval_function)

# Générer la population et exécuter l'algorithme génétique

population = toolbox.population(n=50)
algorithms.eaSimple(population, toolbox, cxpb=0.7, mutpb=0.2, ngen=50, verbose=True)

# Afficher les meilleurs résultats

best_individual = tools.selBest(population, 1)[0]
print("Meilleur individu : ", best_individual)

16.6 Conclusion

Les techniques d’optimisation sont cruciales pour maximiser les performances des modèles
d’apprentissage automatique. La recherche sur la grille et aléatoire sont des approches simples mais
efficaces pour l’optimisation des hyperparamètres. L’optimisation bayésienne et les algorithmes
génétiques offrent des solutions plus avancées et peuvent être particulièrement utiles pour les modèles
complexes et les grands ensembles de données.

Dans ce chapitre, nous avons exploré les différentes techniques d’optimisation et leur mise en œuvre
en Python à l’aide de bibliothèques populaires telles que scikit-learn et scikit-optimize. Ces
outils permettent de rendre l’apprentissage automatique plus efficace et d’obtenir des modèles plus
performants.

Le chapitre suivant sera consacré à l’évaluation des modèles d’apprentissage automatique,

Sènan Elisée AMADE, ISE Page 89

 Python

avec une attention particulière aux méthodes de validation croisée et aux métriques de performance
telles que la précision, le rappel, et le F-score.

Sènan Elisée AMADE, ISE Page 90

Chapitre 17 : Évaluation des Modèles
d’Apprentissage Automatique

L’évaluation d’un modèle d’apprentissage automatique est cruciale pour comprendre sa capacité à
généraliser sur de nouvelles données. Un modèle performant est celui qui ne se contente pas d’apprendre
sur les données d’entraînement, mais qui est également capable de bien prédire sur des données qu’il
n’a jamais vues auparavant. Ce chapitre explore les différentes techniques et métriques utilisées pour
évaluer les modèles d’apprentissage automatique, avec un focus sur la validation croisée, la matrice de
confusion, et d’autres mesures de performance.

17.1 Introduction à l’Évaluation des Modèles

L’évaluation des modèles est essentielle pour mesurer l’efficacité d’un algorithme d’apprentissage
automatique. Il existe plusieurs approches pour effectuer cette évaluation, mais les deux principaux
objectifs sont :

1. Vérifier la performance du modèle sur les données d’entraînement et de test.

2. Comparer différents modèles pour choisir celui qui est le mieux adapté à une tâche spécifique.

Les techniques d’évaluation incluent principalement l’utilisation de jeux de données de validation, ainsi
que des mesures quantitatives de la qualité des prédictions, telles que la précision, le rappel, et le
score F1.

91
 Python

17.2 Validation Croisée (Cross-Validation)

La validation croisée est une méthode d’évaluation très utilisée pour réduire le risque de surajustement
(overfitting) et de sous-ajustement (underfitting). Elle consiste à diviser les données en plusieurs
sous-ensembles, ou “folds”, et à entraîner le modèle sur une combinaison de ces sous-ensembles tout
en testant sa performance sur l’un des sous-ensembles restants. Cela permet de tester le modèle sur
différentes portions des données, assurant ainsi une évaluation plus robuste.

Exemple avec scikit-learn :

from sklearn.model_selection import cross_val_score

from sklearn.svm import SVC

# Créer un modèle
model = SVC()

# Appliquer la validation croisée avec 5 folds

scores = cross_val_score(model, X, y, cv=5)

# Afficher les résultats

print("Scores de validation croisée : ", scores)
print("Score moyen : ", scores.mean())

17.3 Matrice de Confusion

La matrice de confusion est une table utilisée pour évaluer les performances d’un modèle de
classification. Elle compare les prédictions d’un modèle avec les résultats réels. Les éléments clés d’une
matrice de confusion sont :

• Vrai Positif (VP) : Nombre de fois où le modèle a correctement prédit la classe positive.

Sènan Elisée AMADE, ISE Page 92

 Python

• Faux Positif (FP) : Nombre de fois où le modèle a incorrectement prédit la classe positive.
• Vrai Négatif (VN) : Nombre de fois où le modèle a correctement prédit la classe négative.
• Faux Négatif (FN) : Nombre de fois où le modèle a incorrectement prédit la classe négative.

À partir de ces valeurs, vous pouvez calculer diverses métriques de performance.

Exemple avec scikit-learn :

from sklearn.metrics import confusion_matrix

# Prédictions du modèle
y_pred = model.predict(X_test)

# Calcul de la matrice de confusion

cm = confusion_matrix(y_test, y_pred)

print("Matrice de confusion :\n", cm)

17.4 Mesures de Performance

17.4.1 Précision, Rappel et Score F1

Les métriques suivantes sont couramment utilisées pour évaluer la performance des modèles de
classification :

• Précision (Precision) : La précision est la proportion de prédictions positives correctes par

rapport à toutes les prédictions positives effectuées.

VP
Précision =
V P + FP

Sènan Elisée AMADE, ISE Page 93

 Python

• Rappel (Recall) : Le rappel est la proportion de vrais positifs correctement identifiés par
rapport à tous les cas réels positifs.

VP
Rappel =
V P + FN

• Score F1 : Le score F1 est la moyenne harmonique de la précision et du rappel, fournissant une

mesure équilibrée des deux.

Précision × Rappel
F1 = 2 ×
Précision + Rappel

Exemple avec scikit-learn :

from sklearn.metrics import precision_score, recall_score, f1_score

# Calcul des métriques

precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

print("Précision : ", precision)

print("Rappel : ", recall)
print("Score F1 : ", f1)

17.5 Courbe ROC et AUC

La courbe ROC (Receiver Operating Characteristic) est un graphique qui trace le taux de vrais
positifs (sensibilité) en fonction du taux de faux positifs (1 - spécificité) pour différents seuils de
classification. L’aire sous la courbe ROC (AUC) est une mesure de la capacité globale du modèle à
discriminer entre les classes.

Sènan Elisée AMADE, ISE Page 94

 Python

Exemple avec scikit-learn :

from sklearn.metrics import roc_curve, auc

import matplotlib.pyplot as plt

# Calcul des probabilités de prédiction

y_prob = model.predict_proba(X_test)[:, 1]

# Calcul de la courbe ROC

fpr, tpr, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(fpr, tpr)

# Tracer la courbe ROC

plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='Courbe ROC (AUC = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Taux de faux positifs')
plt.ylabel('Taux de vrais positifs')
plt.title('Courbe ROC')
plt.legend(loc="lower right")
plt.show()

17.6 Conclusion

L’évaluation des modèles d’apprentissage automatique est une étape clé pour garantir que nos modèles
sont non seulement performants mais aussi robustes. Les méthodes telles que la validation croisée, la
matrice de confusion, et les mesures de performance offrent une manière systématique d’évaluer
et de comparer les modèles.

Sènan Elisée AMADE, ISE Page 95

 Python

Dans ce chapitre, nous avons exploré des techniques essentielles pour évaluer la qualité de vos modèles
et fournir des informations sur leur efficacité. Il est crucial de choisir les bonnes métriques en fonction
de la nature de votre problème, en particulier si vous travaillez avec des données déséquilibrées ou si
votre priorité est de minimiser les faux positifs ou les faux négatifs.

Dans le chapitre suivant, nous aborderons la mise en production des modèles d’apprentissage
automatique, et comment déployer ces modèles pour qu’ils soient utilisés dans des applications réelles.

Sènan Elisée AMADE, ISE Page 96

Chapitre 18 : Mise en Production des
Modèles d’Apprentissage Automatique

La mise en production des modèles d’apprentissage automatique est l’étape ultime de leur cycle de vie.
Un modèle performant sur un jeu de données de test est utile, mais sa véritable valeur réside dans sa
capacité à être intégré dans des systèmes réels et à fournir des prédictions fiables en production. Ce
chapitre aborde les différentes étapes et bonnes pratiques pour déployer des modèles d’apprentissage
automatique et garantir leur efficacité dans des environnements de production.

18.1 Introduction à la Mise en Production

Mettre un modèle en production implique non seulement d’entraîner le modèle, mais aussi de le
rendre accessible, de garantir sa performance dans le temps et de le surveiller de manière continue.
Contrairement à un modèle utilisé uniquement pour des analyses exploratoires ou des tests, un modèle
en production doit être stable, rapide et résilient face aux changements de données.

Les tâches principales lors de la mise en production incluent :

1. Préparation du modèle : Sauvegarde du modèle entraîné.

2. Intégration dans l’environnement de production : Assurer la compatibilité avec les sys-
tèmes existants.
3. Déploiement : Mettre le modèle en ligne pour effectuer des prédictions sur de nouvelles données.
4. Surveillance continue : Évaluer la performance du modèle en production pour détecter
d’éventuels problèmes.

97
 Python

18.2 Sauvegarde et Chargement du Modèle

Une fois le modèle entraîné, il doit être sauvegardé dans un format qui permet de le recharger facilement
pour une utilisation future. Les formats courants sont Pickle (en Python) et Joblib, qui permettent
de sérialiser l’objet du modèle.

Exemple avec Pickle :

import pickle

# Sauvegarder le modèle
with open('modele_trained.pkl', 'wb') as f:
pickle.dump(model, f)

# Charger le modèle
with open('modele_trained.pkl', 'rb') as f:
model_loaded = pickle.load(f)

Exemple avec Joblib :

import joblib

# Sauvegarder le modèle
joblib.dump(model, 'modele_trained.joblib')

# Charger le modèle
model_loaded = joblib.load('modele_trained.joblib')

Sènan Elisée AMADE, ISE Page 98

 Python

18.3 Déploiement avec une API

Une méthode courante pour déployer un modèle est de créer une API (Application Programming
Interface) qui permet aux utilisateurs ou à d’autres applications d’interagir avec le modèle en envoyant
des données pour des prédictions.

L’une des bibliothèques les plus utilisées pour créer une API en Python est Flask. Voici un exemple
de base pour exposer un modèle de machine learning via une API avec Flask :

Exemple avec Flask :

from flask import Flask, request, jsonify

import joblib

# Charger le modèle
model = joblib.load('modele_trained.joblib')

# Créer l'application Flask

app = Flask(__name__)

# Définir une route pour effectuer des prédictions

@app.route('/predict', methods=['POST'])
def predict():
# Obtenir les données du client
data = request.get_json(force=True)

# Effectuer la prédiction
prediction = model.predict([data['features']])

# Retourner la prédiction sous forme de JSON

return jsonify({'prediction': prediction.tolist()})

Sènan Elisée AMADE, ISE Page 99

 Python

# Démarrer l'application
if __name__ == '__main__':
app.run(debug=True)

Dans cet exemple, l’API expose un point d’entrée /predict qui reçoit des données JSON via une
requête POST et renvoie la prédiction du modèle.

18.4 Déploiement sur le Cloud

Les plateformes de cloud computing comme AWS, Google Cloud, et Microsoft Azure offrent des
services dédiés pour le déploiement de modèles d’apprentissage automatique. Ces services gèrent la
mise en production du modèle et permettent une échelle de traitement plus large.

Par exemple, Amazon SageMaker permet de déployer des modèles de machine learning sans avoir à
se soucier de l’infrastructure. Il vous permet également de surveiller la performance de vos modèles en
production et de les réentraîner si nécessaire.

Avantages du déploiement sur le cloud :

• Scalabilité : Les services cloud permettent de déployer des modèles à grande échelle sans se
soucier de l’infrastructure sous-jacente.
• Gestion des versions : Vous pouvez facilement gérer les versions de vos modèles et suivre les
changements au fil du temps.
• Surveillance : Les plateformes cloud offrent des outils de surveillance qui permettent de suivre
la performance du modèle en production.

Sènan Elisée AMADE, ISE Page 100

 Python

18.5 Surveillance du Modèle en Production

Une fois le modèle déployé, il est essentiel de suivre sa performance en temps réel pour détecter
d’éventuelles dérives ou dégradations dans ses prédictions. Les données en production peuvent changer
au fil du temps, ce qui peut affecter la précision du modèle.

Surveillance continue :

• Drift des données : Les données en production peuvent évoluer, rendant le modèle moins
performant. Le drift des données fait référence aux changements dans la distribution des
données par rapport à celle utilisée lors de l’entraînement.
• Performance du modèle : Il est important de suivre des métriques comme la précision, le
rappel, ou le score F1 en production pour détecter toute dégradation de performance.

Outils de surveillance :

• Prometheus : Utilisé pour surveiller les métriques du système et des applications.

• Grafana : Permet de visualiser et d’analyser ces métriques.
• TensorFlow Model Analysis : Un outil pour surveiller et analyser la performance des modèles
TensorFlow en production.

18.6 Conclusion

La mise en production d’un modèle d’apprentissage automatique est un processus clé qui nécessite une
préparation minutieuse et une gestion continue. Le déploiement dans un environnement de production
peut s’effectuer par le biais d’API, de services cloud, ou en créant des pipelines automatisés. Une
surveillance continue permet de maintenir la performance du modèle sur le long terme et d’identifier
rapidement toute dérive ou dégradation de la qualité des prédictions.

Dans le chapitre suivant, nous explorerons les techniques avancées de machine learning, comme
l’apprentissage profond et les réseaux neuronaux, pour aborder des tâches encore plus complexes.

Sènan Elisée AMADE, ISE Page 101

 Python

Sènan Elisée AMADE, ISE Page 102

Chapitre 19 : Techniques Avancées de
Machine Learning

Une fois que vous avez maîtrisé les concepts de base du machine learning, il est temps de passer aux
techniques avancées. Ce chapitre explore des approches plus complexes, telles que l’apprentissage
profond (Deep Learning), les réseaux neuronaux (Neural Networks), et d’autres méthodes
puissantes utilisées pour résoudre des problèmes plus difficiles dans des domaines comme la reconnais-
sance d’images, la génération de texte, et bien plus encore.

19.1 Introduction à l’Apprentissage Profond (Deep Learning)

L’apprentissage profond est une sous-catégorie de l’apprentissage automatique qui repose sur des
réseaux de neurones complexes pour apprendre des représentations de données à des niveaux multiples
d’abstraction. Cette méthode a révolutionné plusieurs domaines, notamment la vision par ordinateur,
le traitement du langage naturel et les systèmes de recommandation.

Principaux éléments de l’apprentissage profond :

• Réseaux de Neurones Profonds (DNN) : Ce sont des réseaux composés de plusieurs couches
cachées, capables d’apprendre des représentations hiérarchiques des données.
• Réseaux Convolutifs (CNN) : Utilisés principalement pour le traitement d’images et de
vidéos.

103
 Python

• Réseaux Récurrents (RNN) : Adaptés au traitement des données séquentielles, comme le

texte et les séries temporelles.
• Auto-encodeurs : Utilisés pour la réduction de dimensionnalité et la génération de nouvelles
données.

19.2 Réseaux Neuronaux Profonds (DNN)

Les réseaux neuronaux profonds sont composés de plusieurs couches cachées entre l’entrée et la sortie.
Chaque couche apprend des caractéristiques abstraites des données à un niveau de complexité supérieur.
Par exemple, pour une tâche de classification d’images, les premières couches peuvent apprendre des
caractéristiques simples (comme les bords), tandis que les couches profondes apprennent des formes et
des objets plus complexes.

Exemple d’un réseau de neurones simple avec Keras :

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Créer un modèle séquentiel

model = Sequential()

# Ajouter une couche d'entrée

model.add(Dense(64, input_dim=8, activation='relu'))

# Ajouter une couche cachée

model.add(Dense(32, activation='relu'))

# Ajouter une couche de sortie

model.add(Dense(1, activation='sigmoid'))

Sènan Elisée AMADE, ISE Page 104

 Python

# Compiler le modèle
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Résumé du modèle
model.summary()

Dans cet exemple, nous créons un réseau de neurones simple avec deux couches cachées, destiné à
résoudre un problème de classification binaire.

19.3 Réseaux Convolutifs (CNN)

Les réseaux convolutifs sont principalement utilisés pour le traitement d’images. Contrairement aux
réseaux de neurones classiques, les CNN utilisent des filtres convolutifs qui parcourent l’image pour
détecter des motifs. Ils sont particulièrement efficaces pour identifier des objets dans des images et des
vidéos.

Exemple de CNN avec Keras :

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Créer un modèle séquentiel

model = Sequential()

# Ajouter une couche de convolution

model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(64, 64, 3)))

# Ajouter une couche de pooling

model.add(MaxPooling2D(pool_size=(2, 2)))

Sènan Elisée AMADE, ISE Page 105

 Python

# Aplatir les données pour les passer à la couche dense

model.add(Flatten())

# Ajouter une couche dense de sortie

model.add(Dense(1, activation='sigmoid'))

# Compiler le modèle
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Résumé du modèle
model.summary()

Ici, le modèle est configuré pour prendre des images de taille 64x64 et les traiter à l’aide de couches
convolutives et de couches de pooling, avant de passer à une couche dense pour la classification finale.

19.4 Réseaux Neuronaux Récurrents (RNN)

Les réseaux neuronaux récurrents sont conçus pour traiter des données séquentielles, telles que des
séries temporelles ou des textes. Contrairement aux réseaux neuronaux classiques, les RNN ont
des connexions récurrentes qui leur permettent de se souvenir des informations précédentes dans la
séquence.

Exemple d’un RNN simple avec Keras :

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import SimpleRNN, Dense

# Créer un modèle séquentiel

model = Sequential()

Sènan Elisée AMADE, ISE Page 106

 Python

# Ajouter une couche RNN

model.add(SimpleRNN(64, input_shape=(10, 1)))

# Ajouter une couche de sortie

model.add(Dense(1, activation='sigmoid'))

# Compiler le modèle
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Résumé du modèle
model.summary()

Dans cet exemple, le modèle prend une séquence de 10 valeurs et prédit une sortie binaire.

19.5 Amélioration des Performances du Modèle

Une fois que le modèle est construit, il est crucial d’améliorer sa performance en utilisant diverses
techniques :

• Régularisation : Techniques comme la dropout ou la l2 regularization pour éviter le

sur-apprentissage (overfitting).
• Optimisation des hyperparamètres : Utilisation de méthodes comme la recherche aléa-
toire (Random Search) ou la recherche bayésienne pour trouver les meilleurs paramètres
pour le modèle.
• Ensembles de modèles : L’utilisation de plusieurs modèles (par exemple, Random Forests
ou Boosting) pour obtenir des prédictions plus robustes.

Sènan Elisée AMADE, ISE Page 107

 Python

19.6 Conclusion

Les techniques avancées d’apprentissage automatique, telles que l’apprentissage profond, les réseaux
neuronaux, et les réseaux convolutifs ou récurrents, sont des outils puissants pour résoudre des problèmes
complexes dans divers domaines. Leur mise en œuvre nécessite une compréhension approfondie des
architectures de modèles et des bonnes pratiques pour éviter le sur-apprentissage et optimiser les
performances.

Dans le chapitre suivant, nous explorerons les applications pratiques des modèles avancés, en
mettant l’accent sur des cas d’utilisation réels comme la reconnaissance d’images, le traitement du
langage naturel, et la recommandation de produits. Êtes-vous prêt à poursuivre ?

Cela conclut le chapitre sur les techniques avancées de machine learning. Si vous souhaitez en savoir
plus ou si vous avez des ajustements à faire, n’hésitez pas à me le faire savoir !

Voici la conclusion du livre, y compris les références des livres utilisés et le logiciel utilisé pour la
rédaction.

Sènan Elisée AMADE, ISE Page 108

Conclusion

Nous avons couvert un large éventail de sujets concernant l’analyse de données et le machine learning
avec Python, en passant des bases aux techniques avancées, telles que les réseaux de neurones profonds,
les réseaux convolutifs et récurrents. Le machine learning est un domaine vaste et en constante
évolution, et les concepts abordés dans ce livre vous offrent une base solide pour aller plus loin dans la
compréhension et la mise en œuvre de modèles dans divers contextes.

Les chapitres précédents ont montré comment préparer et traiter des données, choisir des modèles
adaptés aux problèmes, et améliorer les performances des modèles. Nous avons également exploré des
techniques avancées comme l’apprentissage profond, la réduction de dimensionnalité, et l’optimisation
des hyperparamètres pour créer des solutions plus performantes et robustes.

Références des Livres et Ressources Utilisées

1. “Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow” par Au-
rélien Géron.
Un excellent livre de référence pour apprendre le machine learning avec Python, abordant des
concepts de base et avancés avec des exemples pratiques.

2. “Deep Learning with Python” par François Chollet.

Ce livre est une ressource incontournable pour quiconque souhaite explorer l’apprentissage
profond. Il est rédigé par l’un des créateurs de Keras et couvre des techniques avancées avec des
explications claires et détaillées.

3. “Python Machine Learning” par Sebastian Raschka et Vahid Mirjalili.

Un livre complet sur le machine learning avec Python qui couvre une large gamme de techniques
allant de l’analyse de données à l’apprentissage profond.

109
 Python

4. Documentation de Keras - Keras Documentation

La documentation officielle de Keras, une bibliothèque Python pour construire des réseaux
neuronaux. C’est une ressource clé pour comprendre les détails de l’API.

5. Documentation de Scikit-Learn - Scikit-Learn Documentation

La bibliothèque Python scikit-learn est l’une des plus populaires pour le machine learning.
Elle propose une large gamme d’algorithmes et d’outils pour le prétraitement des données et
l’évaluation des modèles.

6. “Data Science for Business” par Foster Provost et Tom Fawcett.

Ce livre est essentiel pour comprendre comment appliquer les concepts du machine learning à
des problèmes réels en entreprise.

Logiciels Utilisés pour la Rédaction

La rédaction de ce livre a été réalisée principalement dans un environnement de développement de

code et de traitement de texte. Voici les principaux logiciels utilisés :

1. RMarkdown
Le livre a été rédigé en utilisant RMarkdown, un outil puissant qui permet de combiner du texte,
du code R et Python, ainsi que des résultats interactifs dans un document formaté. RMarkdown
est particulièrement utile pour créer des rapports dynamiques et interactifs, et il permet de
générer facilement des fichiers au format PDF, HTML et Word.

2. Jupyter Notebooks
Jupyter Notebooks a été utilisé pour tester et implémenter des exemples de code Python. Cet
environnement interactif est idéal pour le développement de modèles de machine learning et la
visualisation des résultats, tout en permettant d’exécuter des cellules de code et de documenter
les étapes de manière fluide.

3. VS Code
Visual Studio Code (VS Code) a été utilisé pour la rédaction et la gestion du code source.
Ce logiciel est léger, mais puissant, avec des extensions spécifiques pour Python et R, permettant
d’écrire et de déboguer facilement du code.

Sènan Elisée AMADE, ISE Page 110

 Python

4. GitHub
Pour la gestion de version du code et la collaboration, GitHub a été utilisé. Il permet de suivre
les modifications du code, de collaborer avec d’autres chercheurs et de partager le contenu du
livre avec la communauté.

Remerciements

Un grand merci à vous, le lecteur, pour avoir pris le temps d’explorer ce livre et d’approfondir vos
connaissances en analyse de données et machine learning avec Python. Je vous encourage à appliquer
ces techniques à vos propres projets, à expérimenter et à repousser les limites de ce que vous pouvez
accomplir avec ces outils puissants.

Si vous avez des questions ou souhaitez partager vos retours, n’hésitez pas à me contacter via les
canaux indiqués dans la section “À propos de l’auteur”.

Fin du livre.

Cette version contient une conclusion complète, les références des livres et ressources utilisées,
ainsi que les logiciels employés pour la rédaction du livre. Vous êtes maintenant prêt à publier ce livre
en ligne ! Si vous souhaitez apporter d’autres modifications ou compléter certains aspects, n’hésitez
pas à me le faire savoir.

Sènan Elisée AMADE, ISE Page 111

 Python

Sènan Elisée AMADE, ISE Page 112