Master Big data and Cloud Computing

Cours de Python

Spécialisé Machine Learning

Préparé par : Mohamed Ouazze

24-05-2025
TABLE DES MATIÈRES

Table des matières

1 Introduction 6

Introduction 6

2 Installation et Environnement de travail 7

2.1 Installation via Anaconda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Utilisation de Kaggle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Google Colab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Recommandations pour le choix de l’environnement . . . . . . . . . . . . . . . . . . . . . 9

3 Python - Les bases 10

3.1 Variables et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1.1 Variables et opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1.2 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1.3 Opérations de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.4 Opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.1 Fonctions Lambda (anonymes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.2 Fonctions avec def . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Exercice et solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.4 Structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.4.1 Alternatives If / Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.4.2 Boucle For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4.3 Boucle While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.5 Exercice et solution sur les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . 14
3.6 Structure de données (Listes et Tuples) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.6.1 Création de Listes et de Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.6.2 Indexing et Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.6.3 Actions utiles sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.6.4 Combinaison avec les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . 17
3.7 Exercice et solution sur les structures de données . . . . . . . . . . . . . . . . . . . . . . . 17
3.8 Structure de données (Dictionnaires) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.8.1 Création et utilisation des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . 18
3.8.2 Modification des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.8.3 Accès sécurisé aux valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.8.4 Parcours d’un dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.9 Exercice et solution sur les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.10 Structure de données (List Comprehension) . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.10.1 Syntaxe et avantages des list comprehensions . . . . . . . . . . . . . . . . . . . . . 21
3.10.2 List comprehensions avec conditions . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.10.3 Dictionary comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.11 Exercice et solution sur les comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.12 Fonctions intégrées (Built-in Functions) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.12.1 Fonctions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.12.2 Fonctions de conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.12.3 La fonction input() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.12.4 La fonction format() et les f-strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.12.5 La fonction open() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.13 Exercice et solution sur les fonctions intégrées . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.14 Modules de base de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.14.1 Importation de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.14.2 Modules math et statistics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.14.3 Module random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.14.4 Modules os et glob . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.15 Exercice et solution sur les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.16 Programmation Orientée Objet avec Python . . . . . . . . . . . . . . . . . . . . . . . . . . 28

BDCC-S3-2024-2025 1 Mohamed Ouazze

TABLE DES MATIÈRES

3.16.1 Définition d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.16.2 Création d’une sous-classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Bibliothèques essentielles 30
4.1 NumPy : Tableaux ndarray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.1 Générateurs de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.2 Attributs utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.3 Méthodes importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.1.4 Initialisation personnalisée avec colonne de biais . . . . . . . . . . . . . . . . . . . 31
4.1.5 Indexing et Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.1.6 Indexation booléenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.1.7 Exercices avec solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.2 Statistiques NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3 Opérations linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.4 Exercice : Standardisation de matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.5 Numpy et Broadcasting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.6 Matplotlib : Graphiques de Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.7 Matplotlib : Top Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.7.1 Graphique de Classification avec Scatter() . . . . . . . . . . . . . . . . . . . . . . . 42
4.7.2 Graphiques 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.8 Histogrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.9 Graphiques ContourPlot() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.9.1 Imshow() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.10 Machine Learning avec SciPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.10.1 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.10.2 Optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.10.3 curve_fit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.10.4 Minimisation 1D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.10.5 Minimisation 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.11 Traitement du signal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.12 Transformation de Fourier (FFT) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.13 Traitement d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.14 Application : Traitement d’images (cas réel) . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.15 Pandas (les Bases) et Analyse du Titanic . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.15.1 Chargement des données dans un DataFrame Pandas . . . . . . . . . . . . . . . . . 62
4.15.2 Nettoyage des données avec drop(), dropna() et fillna() . . . . . . . . . . . . . . . . 63
4.15.3 Analyse avec groupby() et value_counts() . . . . . . . . . . . . . . . . . . . . . . . 64
4.16 Exercice : Transformation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.17 Pandas et séries temporelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.17.1 Travailler avec des séries temporelles . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.17.2 Utilisation de resample() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.17.3 Utilisation de agg() pour des statistiques multiples . . . . . . . . . . . . . . . . . . 71
4.17.4 Moyennes mobiles et moyennes mobiles exponentielles (EWM) . . . . . . . . . . . 72
4.17.5 Comparaison de deux séries temporelles . . . . . . . . . . . . . . . . . . . . . . . . 73
4.18 Exercice et Solution : Stratégie de trading simple . . . . . . . . . . . . . . . . . . . . . . . 74
4.19 Visualisation de Données avec Seaborn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.19.1 Prise en main de Seaborn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.19.2 Pairplot() : La vue d’ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.19.3 Visualiser des catégories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.19.4 Visualisation de Distributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

5 Machine Learning 80
5.1 Apprentissage Supervisé avec Sklearn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.1.1 Régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.1.2 Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.1.3 Prédiction de survie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.2 Sklearn : Sélection de Modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.3 Train Test Split . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5.4 Validation Set Approach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

BDCC-S3-2024-2025 2 Mohamed Ouazze

TABLE DES MATIÈRES

5.5 Validation Set et Cross Validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

5.6 Validation Curve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.7 GridSearchCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.8 Confusion Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.9 Learning Curve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.10 Partie 2 : Cross-validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.11 Les erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.11.1 L’Erreur Quadratique Moyenne ou Mean Squared Error (MSE) . . . . . . . . . . . 92
5.11.2 Root Mean Squared Error (RMSE) . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.11.3 Mean Absolute Error (MAE) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
5.12 Analyse de la Performance des Modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.12.1 Coefficient de Détermination (R2 ) . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.12.2 Précision et Rappel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.12.3 F1-score . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.13 Analyse de la Matrice de Confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.13.1 Matrice de Confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.13.2 Calcul des Métriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.14 Exemple de Matrice de Confusion pour une Classification à 3 Classes . . . . . . . . . . . . 98
5.14.1 Matrice de Confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.14.2 Calcul des Métriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.15 Prétraitement des Données avec Sklearn . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
5.15.1 Encodage des Données Catégorielles . . . . . . . . . . . . . . . . . . . . . . . . . . 100
5.15.2 Techniques d’Encodage dans Sklearn . . . . . . . . . . . . . . . . . . . . . . . . . . 100
5.15.3 Encodage avec LabelEncoder et LabelBinarizer . . . . . . . . . . . . . . . . . . . . 100
5.15.4 Utilisation de OneHotEncoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
5.15.5 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
5.16 Normalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
5.16.1 Techniques de Normalisation avec Sklearn . . . . . . . . . . . . . . . . . . . . . . . 103
5.16.2 MinMaxScaler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
5.16.3 StandardScaler (Z-score) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.16.4 RobustScaler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.16.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
5.17 Polynomial Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
5.18 Discrétisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.19 Pipelines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
5.20 Pipeline avec GridSearchCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
5.21 Pipeline Avance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.21.1 make_column_selector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.21.2 make_union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.21.3 Pipelines avec nettoyage de données . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.22 Feature Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
5.22.1 Variance Threshold . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
5.22.2 SelectKBest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
5.22.3 Recursive Feature Elimination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
5.22.4 SelectFromModel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
5.23 Apprentissage Non-Supervisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
5.23.1 K-Means Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
5.23.2 Elbow Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
5.23.3 Détection d’anomalies avec Isolation Forest . . . . . . . . . . . . . . . . . . . . . . 119
5.23.4 Application : Détection d’anomalies sur Digits . . . . . . . . . . . . . . . . . . . . 121
5.23.5 PCA : Réduction de dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
5.24 Ensemble Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.24.1 Voting Classifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
5.24.2 Bagging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
5.24.3 Boosting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
5.24.4 Stacking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

6 Conclusion 130

BDCC-S3-2024-2025 3 Mohamed Ouazze

TABLE DES FIGURES

Table des figures

3 image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4 Exemple de graphique simple montrant une courbe quadratique. . . . . . . . . . . . . . . 38
5 Exemple de graphique scatter montrant des points sur la courbe. . . . . . . . . . . . . . . 39
6 Graphique avec des styles personnalisés : ligne rouge, épaisseur de 4, et ligne en pointillé. 39
7 Exemple de figure avec deux courbes : une quadratique et une cubique. . . . . . . . . . . 40
8 Exemple de subplots montrant deux graphiques sur une même figure. . . . . . . . . . . . . 40
9 Exemple de graphique utilisant la méthode orientée objet avec deux subplots partageant
le même axe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
10 Exemple d’un graphique généré à partir d’un dictionnaire de datasets. . . . . . . . . . . . 41
11 Classification avec Scatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
12 Graphiques 3D avec Scatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
13 Graphiques 3D avec Surface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
14 Histogrammes avec différentes tailles de bins . . . . . . . . . . . . . . . . . . . . . . . . . . 44
15 Histogramme d’une image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
16 Histogramme d’une image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
17 Contours et zones colorées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
18 Visualisations avec imshow() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
19 Visualisation des points d’échantillonnage . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
20 Interpolation 1D avec méthode cubique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
21 Dataset avec bruit normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
22 Modèle ajusté par la méthode des moindres carrés . . . . . . . . . . . . . . . . . . . . . . 49
23 Visualisation de la fonction à minimiser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
24 Résultat de la minimisation 1D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
25 Visualisation de la fonction 2D par courbes de niveau . . . . . . . . . . . . . . . . . . . . 51
26 Résultat de la minimisation 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
27 Signal avec tendance linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
28 Comparaison du signal original et du signal sans tendance . . . . . . . . . . . . . . . . . . 53
29 Signal périodique avec bruit aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
30 Spectre fréquentiel du signal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
31 Spectre après filtrage des composantes de faible amplitude . . . . . . . . . . . . . . . . . . 55
32 Comparaison entre le signal original bruité et le signal reconstruit après filtrage . . . . . . 56
33 Image binaire avec artefacts aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
34 Image après opération morphologique de nettoyage . . . . . . . . . . . . . . . . . . . . . . 58
35 Image originale de bactéries en niveaux de gris . . . . . . . . . . . . . . . . . . . . . . . . 58
36 Histogramme des intensités de pixels de l’image . . . . . . . . . . . . . . . . . . . . . . . . 59
37 Image binarisée des bactéries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
38 Image nettoyée des artefacts par morphologie mathématique . . . . . . . . . . . . . . . . . 60
39 Image segmentée avec chaque bactérie identifiée par une couleur différente . . . . . . . . . 60
40 Distribution des tailles des bactéries identifiées . . . . . . . . . . . . . . . . . . . . . . . . 61
41 Aperçu des 15 premières lignes du jeu de données du Titanic . . . . . . . . . . . . . . . . 62
42 Résumé des informations du DataFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
43 Statistiques descriptives des variables numériques . . . . . . . . . . . . . . . . . . . . . . . 63
44 DataFrame après suppression des colonnes non pertinentes et des lignes avec valeurs man-
quantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
45 Histogramme de la distribution des âges des passagers . . . . . . . . . . . . . . . . . . . . 64
46 Moyennes des variables numériques groupées par sexe . . . . . . . . . . . . . . . . . . . . 64
47 Moyennes des variables numériques groupées par sexe et classe . . . . . . . . . . . . . . . 65
48 Nombre de passagers par classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
49 Nombre de passagers par classe < 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
50 Conversion des catégories de sexe en codes numériques . . . . . . . . . . . . . . . . . . . . 66
51 Aperçu des données Bitcoin avec index temporel . . . . . . . . . . . . . . . . . . . . . . . 67
52 Évolution du prix de clôture du Bitcoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
53 Structure de l’index temporel du DataFrame . . . . . . . . . . . . . . . . . . . . . . . . . 68
54 Prix de clôture du Bitcoin de 2017 à 2019 . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
55 Prix de clôture du Bitcoin en 2019, échantillonné mensuellement . . . . . . . . . . . . . . 69
56 Moyenne bi-hebdomadaire des prix du Bitcoin en 2019 . . . . . . . . . . . . . . . . . . . . 70

BDCC-S3-2024-2025 4 Mohamed Ouazze

TABLE DES FIGURES

57 Comparaison des données journalières, hebdomadaires et mensuelles du Bitcoin . . . . . . 70

58 Moyenne hebdomadaire et plage min-max des prix du Bitcoin en 2019 . . . . . . . . . . . 71
59 Statistiques hebdomadaires des prix du Bitcoin en 2019 . . . . . . . . . . . . . . . . . . . 72
60 Comparaison des moyennes mobiles classiques et exponentielles . . . . . . . . . . . . . . . 72
61 Effet de différentes valeurs d’alpha sur les moyennes mobiles exponentielles . . . . . . . . 73
62 Comparaison des prix de clôture du Bitcoin et de l’Ethereum en septembre 2019 . . . . . 74
63 Stratégie de trading basée sur les extremums glissants appliquée au Bitcoin en 2019 . . . . 75
64 Aperçu du jeu de données Iris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
65 Matrice de nuages de points des caractéristiques d’iris par espèce . . . . . . . . . . . . . . 76
66 Aperçu du jeu de données Titanic nettoyé . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
67 Distribution des âges selon le statut de survie et le genre . . . . . . . . . . . . . . . . . . . 77
68 Boîtes à moustaches des tarifs selon l’âge et le genre . . . . . . . . . . . . . . . . . . . . . 78
69 Distribution des tarifs des passagers du Titanic . . . . . . . . . . . . . . . . . . . . . . . . 78
70 Distribution conjointe hexbin de l’âge et du tarif . . . . . . . . . . . . . . . . . . . . . . . 79
71 Matrice de corrélation des variables du jeu de données Titanic . . . . . . . . . . . . . . . . 79
72 Jeu de données synthétique pour la régression linéaire . . . . . . . . . . . . . . . . . . . . 80
73 Régression linéaire ajustée aux données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
74 Jeu de données Titanic préparé pour la classification . . . . . . . . . . . . . . . . . . . . . 82
75 Évolution de la précision en fonction du nombre de voisins . . . . . . . . . . . . . . . . . . 83
76 Distribution des trois espèces d’iris selon les caractéristiques des sépales . . . . . . . . . . 84
77 Processus de séparation des données en ensembles d’entraînement et de test . . . . . . . . 85
78 Dévision de dataset train test split . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
79 Processus de validation pour la sélection de modèle . . . . . . . . . . . . . . . . . . . . . . 86
80 cross-validation pour différentes valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
81 Résultats de cross-validation pour différentes valeurs de k . . . . . . . . . . . . . . . . . . 87
82 Courbes de validation montrant les performances sur les ensembles d’entraînement et de
validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
83 grid search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
84 Visualisation des résultats de la recherche par grille . . . . . . . . . . . . . . . . . . . . . . 89
85 Matrice Conf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
86 Exemple de matrice de confusion pour le modèle optimisé . . . . . . . . . . . . . . . . . . 89
87 Courbes d’apprentissage montrant l’évolution des performances en fonction de la taille des
données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
88 Illustration de la méthode K-Fold avec 5 folds . . . . . . . . . . . . . . . . . . . . . . . . . 91
89 Illustration de la méthode Leave-One-Out . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
90 Illustration de la méthode ShuffleSplit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
91 Comparaison avant/après normalisation avec MinMaxScaler . . . . . . . . . . . . . . . . . 103
92 Comparaison avant/après normalisation avec Standar Scaler . . . . . . . . . . . . . . . . . 104
93 Comparaison avant/après normalisation avec Robust Scaler . . . . . . . . . . . . . . . . . 105
94 avant crée polyno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
95 Apré crée polyno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
96 Pipline avec Grid SearchCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
97 cartérstique de iris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
98 Données générées avec make_blobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
99 Clusters identifiés par K-Means (points rouges = centres des clusters) . . . . . . . . . . . 118
100 Graphique de la méthode du coude montrant l’inertie en fonction du nombre de clusters . 119
101 Données avec une anomalie visible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
102 Résultat de la détection d’anomalies par Isolation Forest . . . . . . . . . . . . . . . . . . . 120
103 Exemple d’un chiffre manuscrit du jeu de données . . . . . . . . . . . . . . . . . . . . . . 121
104 Les 10 premières anomalies détectées dans le jeu de données Digits . . . . . . . . . . . . . 122
105 Projection des données Digits sur les deux premières composantes principales . . . . . . . 122
106 Affichage des étiquettes des 100 premiers points dans l’espace PCA . . . . . . . . . . . . . 123
107 Variance cumulée expliquée en fonction du nombre de composantes . . . . . . . . . . . . . 123
108 Comparaison entre une image originale et sa version compressée/décompressée par PCA . 124
109 Jeu de données make_moons avec bruit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
110 Frontière de décision d’un Random Forest . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
111 Frontière de décision d’un AdaBoost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
112 Frontière de décision d’un modèle de Stacking . . . . . . . . . . . . . . . . . . . . . . . . . 129

BDCC-S3-2024-2025 5 Mohamed Ouazze

1 INTRODUCTION

1 Introduction
Bienvenue dans ce cours complet de Python appliqué au Machine Learning. Que vous soyez
étudiant, passionné de data science ou professionnel souhaitant acquérir de nouvelles compétences, ce
cours a été conçu pour vous offrir un apprentissage progressif, clair et motivant.
Python est aujourd’hui le langage de prédilection dans le domaine de l’intelligence artificielle, de
la science des données et du développement logiciel. Sa syntaxe simple, sa grande communauté et son
écosystème riche en bibliothèques en font un outil puissant pour manipuler des données, visualiser des
résultats et construire des modèles prédictifs.
Ce cours vous propose une immersion pratique et structurée, depuis les fondamentaux jusqu’aux
techniques de Machine Learning les plus utilisées. Vous apprendrez à écrire du code propre et efficace, à
exploiter des bibliothèques comme NumPy, Pandas ou Scikit-learn, et à créer vos premiers modèles
d’apprentissage automatique.
Pourquoi suivre ce cours ?
— Pour acquérir une base solide en Python, indispensable pour évoluer dans le monde de la data.
— Pour maîtriser les outils incontournables utilisés dans les entreprises, les laboratoires de recherche
et les start-ups.
— Pour comprendre les mécanismes derrière les algorithmes de Machine Learning et savoir les mettre
en œuvre dans des projets concrets.
Le cours est divisé en trois chapitres, chacun construit pour renforcer vos compétences de manière pro-
gressive :
1. Python - Les bases : Variables, opérations, structures de données, conditions, boucles et fonc-
tions.
2. Bibliothèques essentielles : NumPy pour les calculs numériques, Pandas pour la manipulation
de données, Matplotlib pour la visualisation et Scikit-Learn pour le Machine Learning.
3. Machine Learning : Concepts clés (surapprentissage, biais-variance, validation croisée), princi-
paux algorithmes (régression, classification, clustering) et applications pratiques.
À la fin de ce cours, vous serez en mesure de :
— Écrire des scripts Python efficaces
— Manipuler et analyser des jeux de données
— Créer, entraîner et évaluer des modèles de Machine Learning
Alors, prêt(e) à découvrir la puissance de Python et à plonger dans le monde passionnant
du Machine Learning ? Commençons cette aventure ensemble !

BDCC-S3-2024-2025 6 Mohamed Ouazze

2 INSTALLATION ET ENVIRONNEMENT DE TRAVAIL

2 Installation et Environnement de travail

2.1 Installation via Anaconda
Explication

Anaconda est une distribution Python gratuite et open-source qui facilite la gestion des packages
et des environnements virtuels. Pour configurer un environnement de travail pour ce cours, suivez
les étapes ci-dessous :
1. Téléchargez et installez Anaconda depuis https://www.anaconda.com/download/
2. Ouvrez Anaconda Prompt (ou Terminal sur macOS/Linux)
3. Exécutez les commandes suivantes pour créer et configurer votre environnement :

1 conda create -n jupyter_env python =3.9
2 conda activate jupyter_env
3 conda install -c conda - forge notebook =6.4.12 j u p y t e r _ c o n t r i b _ n b e x t e n s i o n s
4 jupyter contrib nbextension install -- sys - prefix

Ces commandes réalisent les actions suivantes :

— Création d’un environnement virtuel nommé jupyter_env avec Python 3.9
— Activation de cet environnement
— Installation de Jupyter Notebook (version 6.4.12) et des extensions supplémentaires
— Configuration des extensions au niveau système
Pour lancer Jupyter Notebook après l’installation :
1. Ouvrez Anaconda Prompt
2. Activez votre environnement : conda activate jupyter_env
3. Lancez Jupyter Notebook : jupyter notebook

Un navigateur web s’ouvrira automatiquement avec l’interface de Jupyter Notebook, vous

permettant de créer ou d’ouvrir des notebooks pour commencer à coder.

BDCC-S3-2024-2025 7 Mohamed Ouazze

2 INSTALLATION ET ENVIRONNEMENT DE TRAVAIL

2.2 Utilisation de Kaggle

Explication

Kaggle offre une alternative en ligne gratuite avec accès à des accélérateurs GPU et TPU, sans
nécessiter d’installation locale.

Kaggle offre hebdomadairement :

— 30 heures en mode GPU
— 26 heures en mode TPU
— Réinitialisation chaque dimanche

Pour configurer un environnement sur Kaggle :

1. Accédez à https://www.kaggle.com/
2. Connectez-vous avec votre compte Google
3. Cliquez sur l’icône de votre compte en haut à droite
4. Sélectionnez "Settings"
5. Ajoutez votre numéro de téléphone pour activer l’accès aux accélérateurs
6. Allez dans la section "Notebook" puis "Create Notebook"
7. Accédez aux paramètres du notebook
8. Dans "Accelerator", sélectionnez l’option souhaitée :
— TPU v3-8
— GPU T4×2
— GPU P100
L’utilisation de Kaggle présente plusieurs avantages :
— Aucune installation locale requise
— Accès gratuit à des GPU/TPU puissants
— Environnement pré-configuré avec les bibliothèques populaires
— Possibilité de partager facilement les notebooks

2.3 Google Colab

Explication

Google Colab est une autre plateforme en ligne qui permet d’exécuter du code Python dans un
navigateur sans configuration locale, avec accès à des GPU et TPU gratuits.
1. Accédez à https://colab.google/
2. Connectez-vous avec votre compte Google
3. Créez un nouveau notebook
4. Pour activer les accélérateurs :
— Accédez à "Exécution" dans le menu
— Sélectionnez "Modifier le type d’exécution"
— Choisissez le type d’accélérateur souhaité (None, GPU, ou TPU)
Google Colab est particulièrement utile pour :
— Les débutants qui ne souhaitent pas configurer un environnement local
— Les projets nécessitant des ressources de calcul importantes
— La collaboration en temps réel
— Le partage facile des notebooks
Les notebooks Colab peuvent être sauvegardés directement sur Google Drive, ce qui facilite l’or-
ganisation et l’accès aux projets depuis n’importe quel appareil.

BDCC-S3-2024-2025 8 Mohamed Ouazze

2 INSTALLATION ET ENVIRONNEMENT DE TRAVAIL

2.4 Recommandations pour le choix de l’environnement

Explication

Le choix de l’environnement dépend de vos besoins spécifiques :

— Anaconda : Idéal pour les développeurs qui souhaitent un contrôle total sur leur environ-
nement, travaillent hors ligne, ou ont besoin de personnalisations avancées.
— Kaggle : Recommandé pour les projets d’analyse de données qui nécessitent des ressources
de calcul importantes ou pour participer à des compétitions de data science.
— Google Colab : Parfait pour les débutants, l’enseignement, ou les projets collaboratifs qui
bénéficient d’une intégration avec l’écosystème Google.
Pour ce cours, n’importe lequel de ces environnements conviendra. Si vous débutez, Google Colab
ou Kaggle sont recommandés pour leur simplicité de mise en œuvre.

Note importante : Pour les exercices nécessitant des ressources de calcul importantes
(notamment en Deep Learning), l’utilisation d’un accélérateur (GPU/TPU) via Kaggle
ou Google Colab est fortement recommandée.

BDCC-S3-2024-2025 9 Mohamed Ouazze

 3 PYTHON - LES BASES

3 Python - Les bases

Python est un langage de programmation interprété, de haut niveau et à usage général. Sa philosophie
met l’accent sur la lisibilité du code et sa syntaxe permet aux programmeurs d’exprimer des concepts en
moins de lignes de code que ce qui serait possible dans des langages comme C++ ou Java.
Ce chapitre couvre les fondamentaux de Python que vous devez maîtriser avant de vous plonger dans
le Machine Learning.

3.1 Variables et fonctions

3.1.1 Variables et opérations
Il existe 4 grands types de variables en Python :
— int (nombre entier)
— float (nombre décimal)
— string (chaîne de caractères)
— bool (booléen)
Voici comment déclarer ces différents types de variables :

1 x = 3 # type int
2 y = 2.5 # type float
3 prenom = ’ Pierre ’ # type string
4 z = True # type bool

Listing 1 – Déclaration de différents types de variables

Pour demander à l’utilisateur de saisir une valeur et la convertir en type float :


1 x = float ( input ( " Saisissez votre variable : " ) )

Listing 2 – Saisie utilisateur avec conversion de type

3.1.2 Opérations arithmétiques

Python permet d’effectuer diverses opérations arithmétiques :

1 print ( ’x + y =’, x + y) # Addition
2 print ( ’x - y =’, x - y) # Soustraction
3 print ( ’x / y =’, x / y) # Division
4 print ( ’x // y = ’ , x // y ) # Division e n t i r e ( t r s utile pour les tableaux NumPy )
5 print ( ’x * y =’, x * y) # Mult iplica tion
6 print ( ’x ** y = ’ , x ** y ) # x puissance y

Listing 3 – Exemples d’opérations arithmétiques

Explication

La division entière (//) est particulièrement utile lorsqu’on travaille avec des tableaux NumPy,
car elle permet de manipuler les indices sans générer d’erreurs liées aux nombres fractionnaires.
Par exemple, si vous devez diviser un tableau en deux parties égales, l’opérateur // garantit que
vous obtiendrez un indice entier.

BDCC-S3-2024-2025 10 Mohamed Ouazze

 3 PYTHON - LES BASES

3.1.3 Opérations de comparaison

Ces opérations renvoient des valeurs booléennes (True ou False) :

1 print ( ’ galit : ’ , x == y )
2 print ( ’ i n g a l i t : ’ , x != y )
3 print ( ’ i n f r i e u r ou gal : ’ , x <= y )
4 print ( ’ s u p r i e u r ou gal : ’ , x >= y )

Listing 4 – Opérations de comparaison

3.1.4 Opérations logiques

Les opérations logiques permettent de combiner des expressions conditionnelles :

1 # AND ( et )
2 print ( True and True ) # True
3 print ( True and False ) # False
4
5 # OR ( ou )
6 print ( True or False ) # True
7 print ( False or False ) # False
8
9 # NOT ( non )
10 print ( not True ) # False
11 print ( not False ) # True

Listing 5 – Opérations logiques

Explication

Les opérations de comparaison et de logique utilisées ensemble permettent de construire des struc-
tures algorithmiques de base (if/else, while, etc.). Elles sont essentielles pour créer des conditions
qui déterminent le flux d’exécution d’un programme.

3.2 Fonctions
En Python, les fonctions sont des blocs de code réutilisables qui exécutent une tâche spécifique. Il
existe deux façons principales de définir des fonctions :

3.2.1 Fonctions Lambda (anonymes)

Une fonction anonyme est créée avec le mot-clé lambda. Ce type de fonction est basique et utile pour
être intégré au sein de structures de contrôle ou d’autres fonctions.

1 # Exemple d ’ une fonction f ( x ) = x
2 f = lambda x : x **2
3 print ( f (3) ) # R s u l t a t : 9
4
5 # Exemple d ’ une fonction g (x , y ) = x - y
6 g = lambda x , y : x **2 - y **2
7 print ( g (4 , 2) ) # R s u l t a t : 12

Listing 6 – Exemples de fonctions lambda

Explication

Les fonctions lambda sont utiles pour les opérations simples qui ne nécessitent pas de bloc de
code complet. Elles sont souvent utilisées comme arguments pour des fonctions de traitement de
données comme map(), filter() ou les méthodes de tri.

BDCC-S3-2024-2025 11 Mohamed Ouazze

 3 PYTHON - LES BASES

3.2.2 Fonctions avec def

La meilleure façon de créer une fonction est d’utiliser la structure def :

1 # Une fonction a un nom , prend des e n t r e s ( arguments ) et les transforme pour retourner
un r s u l t a t
2 def n o m _ d e _ l a _ f o n c t i o n ( argument_1 , argument_2 ) :
3 resultat = argument_1 + argument_2
4 return resultat
5
6 print ( n o m _ d e _ l a _ f o n c t i o n (3 , 2) ) # R sultat: 5

Listing 7 – Définition d’une fonction avec def

Voici un exemple concret - une fonction qui calcule l’énergie potentielle d’un corps :

1 # Fonction qui calcule l ’ nergie potentielle d ’ un corps
2 def e_potentielle ( masse , hauteur , g =9.81) :
3 energie = masse * hauteur * g
4 return energie
5
6 # Ici g a une valeur par d f a u t , donc nous ne sommes pas o b l i g s de lui donner une
valeur
7 resultat = e_potentielle ( masse =10 , hauteur =10)
8 print ( resultat ) # R s u l t a t : 981.0

Listing 8 – Calcul de l’énergie potentielle

Explication

Les paramètres avec des valeurs par défaut (comme g=9.81 dans cet exemple) sont optionnels lors
de l’appel de la fonction. Si aucune valeur n’est fournie, la valeur par défaut sera utilisée. Cela
rend les fonctions plus flexibles et permet de simplifier les appels lorsque des valeurs standards
sont couramment utilisées.

3.3 Exercice et solution

Exercice
Modifiez la fonction e_potentielle définie plus haut pour retourner une valeur booléenne indi-
quant si l’énergie calculée est supérieure ou inférieure à une energie_limite passée en tant que
4ème argument.

Solution

1 def e_potentielle ( masse , hauteur , e_limite , g =9.81) :
2 energie = masse * hauteur * g
3 return energie > e_limite
4
5 resultat = e_potentielle ( masse =10 , hauteur =10 , e_limite =800)
6 print ( resultat ) # R s u l t a t : True ( car 981.0 > 800)

Listing 9 – Solution de l’exercice sur l’énergie potentielle

BDCC-S3-2024-2025 12 Mohamed Ouazze

 3 PYTHON - LES BASES

Explication

Dans cette version modifiée de la fonction, nous ajoutons un paramètre e_limite et nous utilisons
une expression de comparaison pour retourner directement un booléen. La fonction retourne True
si l’énergie calculée est supérieure à la limite, et False dans le cas contraire. Cette technique est
couramment utilisée dans le traitement de données pour filtrer ou classifier des valeurs selon des
seuils définis.

3.4 Structures de contrôle

Dans le monde de la programmation, il existe 3 principales structures de contrôle pour créer des
algorithmes :
— Les alternatives If / Else
— Les boucles For
— Les boucles While

3.4.1 Alternatives If / Else

Cette structure permet de tester une séquence d’alternatives. Si une condition est respectée, alors
les instructions qui la suivent sont exécutées et la structure de contrôle est stoppée, sinon la condition
suivante est testée.

1 def test_du_signe ( valeur ) :
2 if valeur < 0:
3 print ( ’ n g a t i f ’)
4 elif valeur == 0:
5 print ( ’ nul ’)
6 else :
7 print ( ’ positif ’)
8
9 test_du_signe ( -2) # Affiche : n g a t i f

Listing 10 – Fonction utilisant les structures conditionnelles if/elif/else

Explication

Note importante : Une condition est respectée si et seulement si elle correspond au résultat booléen
True.


1 valeur = -2
2 print ( valeur < 0) # Le r s u l t a t de cette comparaison est True
3 if valeur < 0:
4 print ( ’ n g a t i f ’) # Ce bloc est e x c u t car la condition est True

Listing 11 – Évaluation des conditions booléennes

Cela permet de développer des algorithmes avec des mélanges d’opérations logiques et d’opérations de
comparaisons. Par exemple : si il fait beau et qu’il fait chaud, alors j’irai me baigner

1 x = 3
2 y = -1
3 if ( x > 0) and ( y > 0) :
4 print ( ’x et y sont positifs ’)
5 else :
6 print ( ’x et y ne sont pas tous les 2 positifs ’) # Ce bloc est e x cut

Listing 12 – Combinaison de conditions avec opérateurs logiques

BDCC-S3-2024-2025 13 Mohamed Ouazze

 3 PYTHON - LES BASES

3.4.2 Boucle For

Une boucle for permet de créer des algorithmes itératifs (qui effectuent une certaine tâche plusieurs
fois de suite). Pour cela, la boucle parcourt tous les éléments d’un objet dit itérable. Il peut s’agir d’une
liste, d’un dictionnaire, d’un range, d’un tableau NumPy, ou de bien d’autres objets...

1 # range ( d b u t , fin , pas ) est une built - in fonction t r s utile de Python qui retourne un
it rable
2 for i in range (0 , 10) :
3 print ( i ) # Affiche les nombres de 0 9

Listing 13 – Utilisation de la boucle for avec range()


1 # On peut combiner cette boucle avec notre fonction p r c d e n t e
2 for i in range ( -10 , 10 , 2) : # De -10 8 avec un pas de 2
3 print ( i )
4 test_du_signe ( i ) # Appelle la fonction test_du_signe pour chaque valeur

Listing 14 – Combinaison de la boucle for avec une fonction

3.4.3 Boucle While

Une boucle while permet d’effectuer en boucle une action, tant que la condition d’exécution est
validée (tant que la condition est True)

1 x = 0
2 while x < 10:
3 print ( x )
4 x += 1 # I n c r m e n t e x de 1 ( quivalent de x = x +1)

Listing 15 – Utilisation de la boucle while

3.5 Exercice et solution sur les structures de contrôle

Exercice

Implémentez la suite de Fibonacci [0, 1, 1, 2, 3, 5, 8, 13, 21, ...] qui part de 2 nombres a=0 et
b=1, et qui calcule le nombre suivant en additionnant les 2 nombres précédents.
Indices :
— Pour cet exercice vous aurez besoin d’une boucle while
— Vous pouvez imprimer cette suite jusqu’à atteindre un nombre n que vous aurez choisi
— Dans Python il est possible de mettre à jour 2 variables simultanément sur la même ligne :
a, b = b, a+b

Solution

1 def fibonacci ( n ) :
2 # Retourne une liste contenant la suite de Fibonacci jusqu ’ n
3 a = 0
4 b = 1
5 print ( a ) # Affiche le premier nombre de la suite (0)
6 while b < n :
7 print ( b ) # Affiche le nombre actuel
8 a , b = b , a + b # Calcule le nombre suivant
9
10 fibonacci (1000) # Affiche la suite jusqu ’ ce que la valeur d p a s s e 1000

Listing 16 – Implémentation de la suite de Fibonacci

BDCC-S3-2024-2025 14 Mohamed Ouazze

 3 PYTHON - LES BASES

Explication

Cette implémentation de la suite de Fibonacci utilise une boucle while pour générer et afficher
les nombres jusqu’à ce qu’ils dépassent la valeur n spécifiée.
L’utilisation de l’affectation multiple a, b = b, a+b est un exemple de syntaxe élégante en Py-
thon qui permet d’échanger des valeurs sans utiliser de variable temporaire. Cette technique est
particulièrement utile pour la suite de Fibonacci où chaque nouveau terme est la somme des deux
précédents.
Cette séquence apparaît fréquemment dans la nature et dans diverses applications mathématiques.
En informatique, elle est souvent utilisée comme exemple pour introduire la récursivité, même si
cette implémentation utilise une approche itérative plus efficace.

3.6 Structure de données (Listes et Tuples)

Une structure de données est une variable capable de contenir plusieurs valeurs à la fois. Une structure
de données peut former une séquence si les valeurs qui la composent sont rangées dans un certain ordre.
C’est le cas des listes et des tuples. À l’inverse, un dictionnaire ne forme pas une séquence.

3.6.1 Création de Listes et de Tuples

Une liste ou un tuple peuvent contenir tout type de valeurs (int, float, bool, string). On dit que ce
sont des structures hétérogènes. La différence entre les deux est qu’une liste est mutable alors qu’un
tuple ne l’est pas (on ne peut pas le changer après qu’il soit créé).

1 # Listes
2 liste_1 = [1 , 4 , 2 , 7 , 35 , 84]
3 villes = [ ’ Paris ’ , ’ Berlin ’ , ’ Londres ’ , ’ Bruxelles ’]
4 nested_list = [ liste_1 , villes ] # une liste peut m m e contenir des listes ! On appelle
cela une nested list
5
6 # Tuples
7 tuple_1 = (1 , 2 , 6 , 2)
8
9 print ( villes ) # Affiche : [ ’ Paris ’, ’ Berlin ’, ’ Londres ’, ’ Bruxelles ’]

Listing 17 – Création de listes et tuples

Explication

La différence fondamentale entre listes et tuples est leur mutabilité :

— Les listes sont mutables : on peut modifier leur contenu après création (ajouter, supprimer,
remplacer des éléments)
— Les tuples sont immutables : une fois créés, leur contenu ne peut plus être modifié
Les tuples sont généralement utilisés pour représenter des collections de données fixes, comme des
coordonnées (x, y) ou des informations qui ne doivent pas changer.

3.6.2 Indexing et Slicing

Dans une séquence, chaque élément est rangé selon un index (le premier index étant l’index 0). Pour
accéder à un élément d’une liste ou d’un tuple, on utilise une technique appelée Indexing. Pour accéder
à plusieurs éléments d’une liste ou d’un tuple, on utilise une technique appelée Slicing.

1 # INDEXING
2 print ( ’ s q u e n c e c o m p l t e : ’ , villes )
3 print ( ’ index 0: ’ , villes [0]) # Premier lment
4 print ( ’ index 1: ’ , villes [1]) # Deuxi me lment
5 print ( ’ dernier index ( -1) : ’ , villes [ -1]) # Dernier lment

Listing 18 – Accès aux éléments par indexation

BDCC-S3-2024-2025 15 Mohamed Ouazze

 3 PYTHON - LES BASES


1 # SLICING [ d b u t ( inclus ) : fin ( exclus ) : pas ]
2 print ( ’ s q u e n c e c o m p l t e : ’ , villes )
3 print ( ’ index 0 -2: ’ , villes [0:3]) # Les 3 premiers lments
4 print ( ’ index 1 -2: ’ , villes [1:3]) # Du 2 me au 3 me lment
5 print ( ’ ordre inverse : ’ , villes [:: -1]) # Toute la s q u e n c e en ordre inverse

Listing 19 – Extraction d’une partie de la séquence par slicing

Explication

La syntaxe du slicing [début:fin:pas] est très puissante :

— début : indice du premier élément à inclure (inclus)
— fin : indice du dernier élément à considérer (exclu)
— pas : incrément entre les indices
Si l’un de ces paramètres est omis, Python utilise des valeurs par défaut : 0 pour le début, la
longueur de la séquence pour la fin, et 1 pour le pas.

3.6.3 Actions utiles sur les listes


1 villes = [ ’ Paris ’ , ’ Berlin ’ , ’ Londres ’ , ’ Bruxelles ’] # liste initiale
2 print ( villes )
3
4 villes . append ( ’ Dublin ’) # Rajoute un lment la fin de la liste
5 print ( villes )
6
7 villes . insert (2 , ’ Madrid ’) # Rajoute un lment l ’ index i n d i q u
8 print ( villes )
9
10 villes . extend ([ ’ Amsterdam ’ , ’ Rome ’ ]) # Rajoute une liste la fin de notre liste
11 print ( villes )
12
13 print ( ’ longueur de la liste : ’ , len ( villes ) ) # Affiche la longueur de la liste
14
15 villes . sort ( reverse = False ) # Trie la liste par ordre a l p h a b t i q u e / n u m r i q u e
16 print ( villes )
17
18 print ( villes . count ( ’ Paris ’) ) # Compte le nombre de fois qu ’ un lment a p p a r a t dans
la liste

Listing 20 – Opérations courantes sur les listes

Explication

Les méthodes les plus couramment utilisées sur les listes sont :
— append() : ajoute un élément à la fin de la liste
— insert() : insère un élément à une position spécifique
— extend() : ajoute tous les éléments d’une liste à la fin d’une autre
— sort() : trie les éléments de la liste (modifie la liste originale)
— remove() : supprime la première occurrence d’un élément
— pop() : supprime et renvoie un élément à un index donné

BDCC-S3-2024-2025 16 Mohamed Ouazze

 3 PYTHON - LES BASES

3.6.4 Combinaison avec les structures de contrôle

Les listes et les tuples fonctionnent en harmonie avec les structures de contrôle if/else et for.

1 if ’ Paris ’ in villes :
2 print ( ’ oui ’)
3 else :
4 print ( ’ non ’)

Listing 21 – Test d’appartenance avec if/else


1 for element in villes :
2 print ( element )

Listing 22 – Parcours d’une liste avec for

La fonction enumerate est très utile pour extraire à la fois les éléments d’une liste et leurs index. C’est
une fonction très utilisée en data science.

1 for index , element in enumerate ( villes ) :
2 print ( index , element )

Listing 23 – Utilisation de enumerate pour accéder aux indices et valeurs

La fonction zip est aussi très utile pour itérer à travers 2 listes en parallèle. Si une liste est plus courte
que l’autre, la boucle for s’arrête à la liste la plus courte.

1 liste_2 = [312 , 52 , 654 , 23 , 65 , 12 , 678]
2 for element_1 , element_2 in zip ( villes , liste_2 ) :
3 print ( element_1 , element_2 )

Listing 24 – Parcours parallèle de deux listes avec zip

Explication

enumerate() et zip() sont deux fonctions extrêmement utiles en Python pour le traitement de
listes :
— enumerate() retourne des paires (index, valeur) pour chaque élément de la liste
— zip() combine des éléments de même position provenant de plusieurs listes
Ces fonctions permettent d’écrire un code plus élégant et plus efficace, en évitant les index manuels
et les boucles imbriquées.

3.7 Exercice et solution sur les structures de données

Exercice
Transformez le code suivant qui génère la suite de Fibonacci pour enregistrer les résultats dans
une liste et retourner cette liste à la fin de la fonction :

1 # Code original :
2 def fibonacci ( n ) :
3 a = 0
4 b = 1
5 while b < n :
6 a, b = b, a+b
7 print ( a )

BDCC-S3-2024-2025 17 Mohamed Ouazze

 3 PYTHON - LES BASES

Solution

1 def fibonacci ( n ) :
2 a = 0
3 b = 1
4 fib = [ a ] # C r a t i o n d ’ une liste fib avec le premier lment
5 while b < n :
6 a, b = b, a+b
7 fib . append ( a ) # Ajoute la nouvelle valeur de a la fin de fib
8 return fib
9
10 print ( fibonacci (1000) ) # Affiche la liste c o m p l t e des nombres de Fibonacci jusqu
’ 1000

Listing 25 – Implémentation de Fibonacci avec stockage dans une liste

Explication

Cette solution améliore le code original de plusieurs façons :

— Au lieu d’afficher chaque nombre individuellement, nous les stockons dans une liste fib
— Nous initialisons la liste avec le premier terme de la suite (0)
— À chaque itération, nous ajoutons le nouveau terme à la liste avec append()
— Nous retournons la liste complète à la fin, ce qui permet de l’utiliser pour d’autres calculs
ou analyses
Cette technique de stockage des résultats dans une structure de données est couramment utili-
sée en data science pour conserver un historique des valeurs calculées et permettre des analyses
ultérieures.

3.8 Structure de données (Dictionnaires)

Contrairement aux listes et aux tuples qui sont des séquences ordonnées, les dictionnaires sont des
structures de données non-ordonnées où les valeurs sont accessibles via des clés uniques plutôt que
par indexation numérique.

3.8.1 Création et utilisation des dictionnaires

Un dictionnaire permet d’associer des valeurs à des clés spécifiques. Une utilisation typique est de
regrouper plusieurs informations liées dans un même conteneur.

1 # C r a t i o n d ’ un dictionnaire d ’ inventaire
2 inventaire = { ’ pommes ’: 100 ,
3 ’ bananes ’: 80 ,
4 ’ poires ’: 120}
5
6 # A c c s aux informations du dictionnaire
7 print ( inventaire . values () ) # Affiche toutes les valeurs
8 print ( inventaire . keys () ) # Affiche toutes les c l s
9 print ( len ( inventaire ) ) # Affiche le nombre d ’ lments dans le dictionnaire

Listing 26 – Création et utilisation basique d’un dictionnaire

Explication

Un dictionnaire Python est une collection d’associations clé-valeur où :

— Chaque clé doit être unique
— Les clés doivent être d’un type immuable (chaînes, nombres, tuples)
— L’ordre des éléments n’est pas garanti (bien que depuis Python 3.7, l’ordre d’insertion soit
préservé)

BDCC-S3-2024-2025 18 Mohamed Ouazze

 3 PYTHON - LES BASES

3.8.2 Modification des dictionnaires

Voici comment ajouter ou modifier des associations clé/valeur dans un dictionnaire :

1 # Ajouter une nouvelle e n t r e
2 inventaire [ ’ abricots ’] = 30
3
4 # Modifier une valeur existante
5 inventaire [ ’ bananes ’] = 30
6
7 print ( inventaire ) # Affiche le dictionnaire mis jour

Listing 27 – Modification d’un dictionnaire

Explication

Un dictionnaire étant mutable, vous pouvez :

— Ajouter de nouvelles paires clé-valeur avec la syntaxe dictionnaire[nouvelle_clé] =
valeur
— Modifier une valeur existante avec la même syntaxe dictionnaire[clé_existante] =
nouvelle_valeur
— Supprimer des éléments avec les méthodes pop() ou del dictionnaire[clé]

3.8.3 Accès sécurisé aux valeurs

Attention : si vous cherchez une clé qui n’existe pas dans un dictionnaire, Python génère une erreur
KeyError. Pour éviter cela, vous pouvez utiliser la méthode get() :

1 # R c u p r a t i o n d ’ une valeur pour une c l qui n ’ existe pas
2 print ( inventaire . get ( ’ peches ’) ) # Retourne None , car ’ peches ’ n ’ existe pas
3
4 # R c u p r a t i o n d ’ une valeur pour une c l qui existe
5 print ( inventaire . get ( ’ pommes ’) ) # Retourne la valeur a s s o c i e ’ pommes ’

Listing 28 – Utilisation de la méthode get() pour un accès sécurisé

La méthode pop() permet de retirer une clé d’un dictionnaire tout en retournant la valeur associée :

1 # Supprime la c l ’ abricots ’ et stocke sa valeur
2 abricots = inventaire . pop ( " abricots " )
3 print ( inventaire ) # Ne contient plus de c l ’ abricots ’
4 print ( abricots ) # Contient la valeur a s s o c i e ’ abricots ’

Listing 29 – Utilisation de la méthode pop()

3.8.4 Parcours d’un dictionnaire

Pour utiliser une boucle for avec un dictionnaire, il est utile d’employer la méthode items() qui
retourne à la fois les clés et les valeurs :

1 # I t r a t i o n sur les paires c l - valeur
2 for key , value in inventaire . items () :
3 print ( key , value )

Listing 30 – Parcours d’un dictionnaire avec items()

BDCC-S3-2024-2025 19 Mohamed Ouazze

3 PYTHON - LES BASES

Explication

Plusieurs méthodes permettent de parcourir un dictionnaire :

— dictionnaire.keys() - pour itérer à travers les clés uniquement
— dictionnaire.values() - pour itérer à travers les valeurs uniquement
— dictionnaire.items() - pour itérer à travers les paires clé-valeur

3.9 Exercice et solution sur les dictionnaires

Exercice
Implémentez une fonction trier(classeur, valeur) qui place une valeur dans un dictionnaire
en fonction de son signe.

1 classeur = { ’ n g a t i f s ’ :[] ,
2 ’ positifs ’ :[]}
3
4 def trier ( classeur , valeur ) :
5 # C o m p l t e z cette fonction
6 return classeur

Solution

1 def trier ( classeur , valeur ) :
2 if valeur >= 0:
3 classeur [ ’ positifs ’ ]. append ( valeur )
4 else :
5 classeur [ ’ n g a t i f s ’ ]. append ( valeur )
6 return classeur
7
8 # Test de la fonction
9 classeur = { ’ n g a t i f s ’ :[] , ’ positifs ’ :[]}
10 print ( trier ( classeur , 9) ) # Ajoute 9 la liste des positifs
11 print ( trier ( classeur , -3) ) # Ajoute -3 la liste des n g a t i f s
12 print ( trier ( classeur , 0) ) # Ajoute 0 la liste des positifs

Listing 31 – Implémentation de la fonction de tri par signe

Explication

Cette solution illustre plusieurs concepts clés :

— Utilisation d’un dictionnaire contenant des listes comme valeurs
— Test conditionnel pour déterminer la catégorie appropriée
— Ajout d’une valeur à la liste correspondante avec append()
— Retour du dictionnaire modifié pour permettre l’enchaînement d’opérations
Cette technique est couramment utilisée en analyse de données pour classifier ou regrouper des
éléments selon différents critères.

3.10 Structure de données (List Comprehension)

Les list comprehensions sont une façon élégante et concise de créer des listes en Python sur une
seule ligne de code. Cette syntaxe rend non seulement le code plus lisible, mais aussi significativement
plus rapide à l’exécution par rapport aux méthodes traditionnelles.

BDCC-S3-2024-2025 20 Mohamed Ouazze

 3 PYTHON - LES BASES

3.10.1 Syntaxe et avantages des list comprehensions

Les list comprehensions offrent une alternative très efficace aux boucles for traditionnelles pour la
création et le remplissage de listes.

1 # M t h o d e tr aditio nnelle avec append ()
2 %% time
3 liste = []
4 for i in range (100000) :
5 liste . append ( i **2)
6
7 # M t h o d e avec list comprehension
8 %% time
9 liste = [ i **2 for i in range (100000) ]

Listing 32 – Comparaison de performance entre méthode traditionnelle et list comprehension

Explication

Les list comprehensions présentent plusieurs avantages :

— Performance : elles sont généralement plus rapides car optimisées au niveau de l’inter-
préteur Python
— Concision : elles permettent d’exprimer en une ligne ce qui nécessiterait plusieurs lignes
avec la méthode traditionnelle
— Lisibilité : une fois maîtrisées, elles rendent le code plus expressif et facile à comprendre

3.10.2 List comprehensions avec conditions

On peut ajouter des conditions de type if dans les list comprehensions pour filtrer les éléments :

1 # C r a t i o n d ’ une liste contenant les c a r r s des nombres pairs uniquement
2 liste = [ i **2 for i in range (100000) if ( i % 2) == 0]
3 print ( liste [:10]) # Affiche les 10 premiers lments de la liste

Listing 33 – List comprehension avec filtrage conditionnel

Explication

La structure générale d’une list comprehension avec condition est :

[expression for variable in itérable if condition]
Seuls les éléments qui satisfont la condition seront inclus dans la liste résultante après application
de l’expression.

3.10.3 Dictionary comprehensions

Le même principe s’applique également aux dictionnaires, permettant de créer des dictionary com-
prehensions :

1 # C r a t i o n d ’ un dictionnaire avec les nombres de 1 20 comme c l s et leurs c a r r s
comme valeurs
2 dictionnaire = { k : k **2 for k in range (1 , 21) }
3 print ( dictionnaire )

Listing 34 – Dictionary comprehension pour génération de paires clé-valeur

BDCC-S3-2024-2025 21 Mohamed Ouazze

 3 PYTHON - LES BASES

Explication

La syntaxe des dictionary comprehensions est similaire à celle des list comprehensions, mais utilise
des accolades {} et spécifie à la fois une clé et une valeur :
{clé: valeur for variable in itérable if condition}

Cette technique permet de créer des dictionnaires de manière concise et efficace, en évitant les
boucles explicites et les affectations répétitives.

3.11 Exercice et solution sur les comprehensions

Exercice
Créez un dictionnaire qui contienne des clés de 1 à 20, avec comme valeur le carré de chaque clé.

Solution

1 dictionnaire = { k : k **2 for k in range (1 , 21) }
2 print ( dictionnaire )

Listing 35 – Création d’un dictionnaire avec dictionary comprehension

Explication

Cette solution utilise une dictionary comprehension pour créer un dictionnaire en une seule ligne :
— k sert à la fois de clé dans le dictionnaire et de variable d’itération
— k**2 calcule le carré de chaque nombre comme valeur associée
— range(1, 21) génère tous les nombres de 1 à 20 inclus
Les comprehensions constituent un outil puissant en Python pour l’analyse de données et le trai-
tement de collections d’éléments, permettant d’écrire du code à la fois concis et performant.

3.12 Fonctions intégrées (Built-in Functions)

Python dispose d’un grand nombre de fonctions intégrées (built-in functions) qui facilitent le déve-
loppement de programmes en fournissant des fonctionnalités prêtes à l’emploi pour les tâches courantes.
Cette section présente les fonctions les plus utiles, regroupées par catégories.

3.12.1 Fonctions de base


1 x = -3.14
2 print ( abs ( x ) ) # Valeur absolue
3 print ( round ( x ) ) # Arrondi
4
5 liste = [ -2 , 3 , 1 , 0 , -4]
6 print ( min ( liste ) ) # Minimum
7 print ( max ( liste ) ) # Maximum
8 print ( len ( liste ) ) # Longueur
9 print ( sum ( liste ) ) # Somme des lments
10
11 liste = [ False , False , True ]
12 print ( any ( liste ) ) # Y a -t - il au moins un lment True ?
13 print ( all ( liste ) ) # Est - ce que tous les lments sont True ?

Listing 36 – Exemples de fonctions de base

BDCC-S3-2024-2025 22 Mohamed Ouazze

 3 PYTHON - LES BASES

Explication

Les fonctions intégrées de base permettent d’effectuer des opérations communes :

— abs() : retourne la valeur absolue d’un nombre
— round() : arrondit un nombre à l’entier le plus proche
— min() et max() : trouvent respectivement le minimum et le maximum d’une séquence
— len() : calcule la longueur d’une séquence (liste, tuple, chaîne, etc.)
— sum() : calcule la somme des éléments d’une séquence
— any() : retourne True si au moins un élément de la séquence est vrai
— all() : retourne True si tous les éléments de la séquence sont vrais

3.12.2 Fonctions de conversion

Il est souvent nécessaire de convertir une variable d’un type à un autre, par exemple pour effectuer
des calculs numériques sur des données initialement stockées sous forme de texte.

1 age = ’ 32 ’
2 print ( type ( age ) ) # Affiche le type de la variable : < class ’ str ’>
3
4 age = int ( age ) # Conversion en entier
5 print ( type ( age ) ) # < class ’ int ’>
6 print ( age + 10) # Maintenant on peut faire des calculs : 42
7
8 # Conversion entre structures de d o n n e s
9 tuple_1 = (1 , 2 , 3 , 4)
10 liste_1 = list ( tuple_1 ) # Convertir un tuple en liste
11 print ( type ( liste_1 ) ) # < class ’ list ’>

Listing 37 – Conversion de types

Explication

Les fonctions de conversion les plus utilisées sont :

— int(), float(), str() : convertissent entre types numériques et chaînes
— list(), tuple(), set(), dict() : convertissent entre différentes structures de données
— bin(), oct(), hex() : convertissent des entiers en représentations binaire, octale et hexa-
décimale
— type() : retourne le type d’un objet (utile pour le débogage)

3.12.3 La fonction input()

Cette fonction permet d’interagir avec l’utilisateur en récupérant des données saisies au clavier.

1 # La fonction input () retourne toujours une c h a n e de c a r a c t r e s
2 age = input ( ’ Quel ge avez - vous ? ’)
3
4 # Pour utiliser la valeur dans un calcul , il faut la convertir
5 age = int ( age )
6 print ( f " Dans 10 ans , vous aurez { age + 10} ans . " )

Listing 38 – Utilisation de la fonction input()

Explication

Points importants concernant input() :

— Retourne toujours une chaîne de caractères, quelle que soit la saisie de l’utilisateur
— Nécessite généralement une conversion explicite vers le type approprié (int, float, etc.)
— Bloque l’exécution du programme jusqu’à ce que l’utilisateur valide sa saisie

BDCC-S3-2024-2025 23 Mohamed Ouazze

 3 PYTHON - LES BASES

3.12.4 La fonction format() et les f-strings

Ces fonctionnalités permettent d’insérer facilement des valeurs de variables dans des chaînes de ca-
ractères.

1 x = 25
2 ville = ’ Paris ’
3
4 # M t h o d e avec format ()
5 message = ’ Il fait {} d e g r s {} ’. format (x , ville )
6 print ( message )
7
8 # M t h o d e avec f - string ( plus concise , disponible depuis Python 3.6)
9 message = f ’ Il fait { x } d e g r s { ville } ’
10 print ( message )

Listing 39 – Formatage de chaînes

Explication

Les f-strings (chaînes de caractères préfixées de f) constituent la méthode la plus moderne et la

plus lisible pour formater des chaînes en Python. Ils permettent :
— D’insérer directement des expressions dans des accolades {}
— D’appliquer des opérations de formatage avancées (précision, alignement, etc.)
— D’optimiser les performances par rapport aux autres méthodes de formatage

3.12.5 La fonction open()

Cette fonction essentielle permet de manipuler des fichiers externes, en lecture ou en écriture.

1 # criture dans un fichier
2 f = open ( ’ text . txt ’ , ’w ’) # Ouverture en mode criture
3 f . write ( ’ hello ’)
4 f . close () # Important : fermer le fichier a p r s utilisation
5
6 # Lecture d ’ un fichier
7 f = open ( ’ text . txt ’ , ’r ’) # Ouverture en mode lecture
8 print ( f . read () )
9 f . close ()
10
11 # Utilisation du gestionnaire de contexte with ( r e c o m m a n d )
12 with open ( ’ text . txt ’ , ’r ’) as f :
13 print ( f . read () ) # Fermeture automatique a p r s le bloc with

Listing 40 – Manipulation de fichiers avec open()

Explication

La fonction open() accepte différents modes d’ouverture :

— ’r’ : lecture (mode par défaut)
— ’w’ : écriture (crée le fichier s’il n’existe pas, le vide s’il existe)
— ’a’ : ajout (append) à la fin du fichier
— ’r+’, ’w+’, ’a+’ : modes combinés lecture/écriture
— ’b’ : à ajouter pour le mode binaire (ex : ’rb’, ’wb’)
L’utilisation du gestionnaire de contexte with est fortement recommandée car il assure la fermeture
du fichier même en cas d’exception.

BDCC-S3-2024-2025 24 Mohamed Ouazze

3 PYTHON - LES BASES

3.13 Exercice et solution sur les fonctions intégrées

Exercice
Le code ci-dessous permet de créer un fichier qui contient les nombres carrés de 0 jusqu’à 19.
L’exercice consiste à implémenter un code qui permet de lire ce fichier et d’écrire chaque ligne
dans une liste.
Note 1 : La méthode read().splitlines() sera très utile.
Note 2 : Pour un meilleur résultat, essayez d’utiliser une list comprehension !

1 # Ce bout de code permet d ’ crire le fichier
2 with open ( ’ fichier . txt ’ , ’w ’) as f :
3 for i in range (0 , 20) :
4 f . write ( f ’{ i }: { i **2} \ n ’)

Solution

1 # Solution non optimale
2 with open ( ’ fichier . txt ’ , ’r ’) as f :
3 liste = f . read () . splitlines ()
4
5 print ( liste )

Listing 41 – Solution sans list comprehension


1 # Solution a m l i o r e avec list comprehension
2 liste = [ row . strip () for row in open ( ’ fichier . txt ’ , ’r ’) ]
3 print ( liste )

Listing 42 – Solution avec list comprehension

Explication

Les deux solutions accomplissent la même tâche, mais la seconde utilise une list comprehension
pour un code plus concis :
— La première solution utilise read().splitlines() pour lire tout le fichier et le diviser en
lignes
— La seconde itère directement sur le fichier (qui est itérable ligne par ligne) et applique
strip() pour éliminer les espaces et retours à la ligne superflus
— La list comprehension offre une syntaxe plus élégante et souvent plus performante
Dans des applications réelles traitant de grands fichiers, on préférerait généralement la seconde
approche car elle consomme moins de mémoire en traitant les lignes une par une plutôt qu’en
chargeant tout le fichier d’un coup.

3.14 Modules de base de Python

Python contient un certain nombre de modules intégrés qui offrent des fonctionnalités supplémentaires
aux fonctions de base. Ces modules proposent des fonctions mathématiques, statistiques, aléatoires et
d’interaction avec le système d’exploitation qui sont très utiles pour le développement de programmes.

BDCC-S3-2024-2025 25 Mohamed Ouazze

 3 PYTHON - LES BASES

3.14.1 Importation de modules

Il existe plusieurs façons d’importer un module en Python :

1 # Importe tout le module
2 import math
3
4 # Importe le module avec un alias
5 import statistics as stats
6
7 # Importe seulement des fonctions s p c i f i q u e s du module
8 from random import randint , choice

Listing 43 – Différentes méthodes d’importation de modules

Explication

Les trois principales méthodes d’importation offrent différents avantages :

— import module : importe le module complet, les fonctions sont accessibles via
module.fonction()
— import module as alias : donne un nom plus court au module, les fonctions sont acces-
sibles via alias.fonction()
— from module import fonction : importe uniquement les fonctions spécifiées, qui sont
directement accessibles par leur nom fonction()
On peut également créer ses propres modules, qui ne sont rien d’autre que des fichiers Python
contenant des fonctions et des classes.

3.14.2 Modules math et statistics

Les modules math et statistics fournissent des fonctions mathématiques et statistiques de base.

1 import math
2 import statistics
3
4 print ( math . pi ) # Affiche la constante
5 print ( math . cos (2* math . pi ) ) # Calcule le cosinus de 2
6
7 liste = [1 , 4 , 6 , 2 , 5]
8 print ( statistics . mean ( liste ) ) # Moyenne de la liste
9 print ( statistics . variance ( liste ) ) # Variance de la liste

Listing 44 – Utilisation des modules math et statistics

Explication

Bien que ces modules soient utiles pour des calculs simples, en data science, on préférera gé-
néralement utiliser leurs équivalents dans le package NumPy, qui offre des performances bien
supérieures pour les calculs sur de grandes quantités de données.

3.14.3 Module random

Le module random permet de générer des nombres aléatoires et d’effectuer des sélections aléatoires.

1 import random
2
3 random . seed (0) # Fixe le g n r a t e u r a l a t o i r e pour produire toujours le m m e
r sultat
4 liste = [1 , 4 , 6 , 2 , 5]
5
6 print ( random . choice ( liste ) ) # Choisit un lment au hasard dans la liste
7 print ( random . random () ) # G n r e un nombre a l a t o i r e entre 0 et 1
8 print ( random . randint (5 , 10) ) # G n r e un nombre entier a l a t o i r e entre 5 et 10

BDCC-S3-2024-2025 26 Mohamed Ouazze

 3 PYTHON - LES BASES

9
10 # G n r e une liste de 10 nombres a l a t o i r e s entre 0 et 99
11 print ( random . sample ( range (100) , 10) )
12
13 print ( ’ liste de d p a r t ’ , liste )
14 random . shuffle ( liste ) # M l a n g e les lments d ’ une liste
15 print ( ’ liste m l a n g e ’ , liste )

Listing 45 – Utilisation du module random

Explication

Le module random offre plusieurs fonctions importantes :

— random.seed() : initialise le générateur de nombres aléatoires, utile pour la reproductibilité
— random.random() : génère un nombre à virgule flottante entre 0.0 et 1.0
— random.randint(a, b) : génère un entier aléatoire entre a et b inclus
— random.choice(séquence) : sélectionne un élément aléatoire d’une séquence
— random.sample(population, k) : sélectionne k éléments uniques de la population
— random.shuffle(séquence) : mélange les éléments d’une séquence sur place
En data science, on préfère généralement les fonctions équivalentes du module numpy.random pour
leur performance et leur intégration avec les tableaux NumPy.

3.14.4 Modules os et glob

Les modules os et glob permettent d’interagir avec le système d’exploitation et le système de fichiers.

1 import os
2 import glob
3
4 # Affiche le r p e r t o i r e de travail actuel
5 print ( os . getcwd () )
6
7 # Liste tous les fichiers du r p e r t o i r e courant
8 print ( glob . glob ( ’* ’) )

Listing 46 – Utilisation des modules os et glob

Explication

Ces modules sont particulièrement utiles pour :

— Naviguer dans l’arborescence des fichiers
— Créer ou supprimer des répertoires et des fichiers
— Obtenir des informations sur les fichiers (taille, date de modification, etc.)
— Rechercher des fichiers correspondant à certains motifs
— Exécuter des commandes du système d’exploitation
En analyse de données, ces modules sont souvent utilisés pour localiser et traiter des fichiers de
données en masse.

3.15 Exercice et solution sur les modules

Exercice
Créez une fonction qui utilise le module random pour générer une liste de 10 nombres entiers
aléatoires entre 1 et 100, puis calcule et retourne leur moyenne à l’aide du module statistics.

BDCC-S3-2024-2025 27 Mohamed Ouazze

 3 PYTHON - LES BASES

Solution

1 import random
2 import statistics
3
4 def m o y e n n e _ a l e a t o i r e () :
5 # G n r e 10 nombres a l a t o i r e s entre 1 et 100
6 nombres = [ random . randint (1 , 100) for _ in range (10) ]
7
8 # Calcule et retourne leur moyenne
9 moyenne = statistics . mean ( nombres )
10
11 print ( f " Nombres g n r s : { nombres } " )
12 print ( f " Moyenne : { moyenne } " )
13
14 return moyenne
15
16 # Test de la fonction
17 m o y e n n e _ a l e a t o i r e ()

Listing 47 – Utilisation combinée des modules random et statistics

Explication

Cette solution illustre l’utilisation combinée de deux modules Python :

— random.randint() pour générer des nombres aléatoires dans une plage spécifiée
— statistics.mean() pour calculer la moyenne arithmétique d’une séquence
— Une list comprehension pour créer efficacement la liste de nombres aléatoires
Le résultat sera différent à chaque exécution (sauf si on utilise random.seed() pour fixer le gé-
nérateur aléatoire). Cette technique de génération de données aléatoires est souvent utilisée pour
tester des algorithmes ou simuler des scénarios.

3.16 Programmation Orientée Objet avec Python

La programmation orientée objet (POO) est un paradigme de programmation qui permet de modéliser
des entités du monde réel sous forme d’objets, caractérisés par des attributs (données) et des méthodes
(fonctions associées). En Python, presque tout est un objet : les chaînes de caractères, les listes, les
dictionnaires, etc.

3.16.1 Définition d’une classe

Une classe est une sorte de plan de fabrication d’objet. Elle définit quels attributs et méthodes chaque
objet de ce type possèdera.

1 class Vehicule :
2 """
3 Exemple de classe r e p r s e n t a n t un v h i c u l e .
4 """
5
6 # M t h o d e d ’ initi alisat ion avec des attributs
7 def __init__ ( self , couleur = ’ noire ’ , vitesse =0 , roues =4) :
8 self . couleur = couleur
9 self . vitesse = vitesse
10 self . roues = roues
11
12 # M t h o d e pour a c c l r e r
13 def accelerer ( self , vitesse ) :
14 self . vitesse += vitesse
15
16 # M t h o d e pour a r r t e r le v h i c u l e
17 def stop ( self ) :
18 self . vitesse = 0
19

BDCC-S3-2024-2025 28 Mohamed Ouazze

 3 PYTHON - LES BASES

20 # M t h o d e d ’ affichage des attributs

21 def afficher ( self ) :
22 print ( f " couleur : { self . couleur } " )
23 print ( f " roues : { self . roues } " )
24 print ( f " vitesse : { self . vitesse } " )
25
26 # C r a t i o n et utilisation d ’ un objet
27 voiture_1 = Vehicule ( couleur = ’ rouge ’)
28 voiture_1 . accelerer (100)
29 voiture_1 . afficher ()

Listing 48 – Définition d’une classe simple et instanciation d’un objet

Explication

Ce code montre la création d’une classe Vehicule avec des attributs (couleur, vitesse, roues)
définis dans la méthode spéciale __init__().
— self fait référence à l’objet courant.
— On crée un objet avec Vehicule(...).
— On accède aux méthodes via objet.méthode().

3.16.2 Création d’une sous-classe

Une sous-classe hérite des attributs et des méthodes d’une classe parent. On peut aussi redéfinir des
méthodes ou en ajouter de nouvelles.

1 class V o i t u r e E l e c t r i q u e ( Vehicule ) :
2 """
3 Classe r e p r s e n t a n t une voiture lectrique .
4 H r i t e de la classe Vehicule .
5 """
6
7 def __init__ ( self , couleur = ’ black ’ , vitesse =0 , roues =4 , autonomie =100) :
8 super () . __init__ ( couleur , vitesse , roues ) # Appel au constructeur de la classe
parent
9 self . autonomie = autonomie
10
11 # Surcharge de la m t h o d e accelerer
12 def accelerer ( self , vitesse ) :
13 super () . accelerer ( vitesse )
14 self . autonomie -= 0.1 * self . vitesse
15
16 # Affichage tendu
17 def afficher ( self ) :
18 super () . afficher ()
19 print ( f " autonomie : { self . autonomie } " )
20
21 # C r a t i o n d ’ une instance de la classe d riv e
22 voiture_2 = V o i t u r e E l e c t r i q u e ()
23 voiture_2 . afficher ()
24
25 voiture_2 . accelerer (10)
26 voiture_2 . afficher ()

Listing 49 – Héritage avec une classe dérivée

Explication

Voici les points clés de ce code :

— La classe VoitureElectrique hérite de Vehicule.
— super() permet d’accéder aux méthodes de la classe parente.
— On redéfinit la méthode accelerer() pour modifier aussi l’attribut autonomie.
Ce mécanisme d’héritage permet de créer des structures complexes à partir de bases simples, tout
en réutilisant du code existant.

BDCC-S3-2024-2025 29 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4 Bibliothèques essentielles
Python dispose d’un écosystème très riche de bibliothèques scientifiques. Dans ce chapitre, nous al-
lons nous concentrer sur NumPy, une bibliothèque fondamentale pour la manipulation de données
numériques, notamment les tableaux multidimensionnels appelés ndarray.

4.1 NumPy : Tableaux ndarray

4.1.1 Générateurs de tableaux

1 import numpy as np
2
3 A = np . array ([1 , 2 , 3]) # Conversion d ’ une liste en tableau
4 A = np . zeros ((2 , 3) ) # Tableau de z r o s
5 B = np . ones ((2 , 3) ) # Tableau de uns
6 C = np . random . randn (2 , 3) # A l a t o i r e - distribution normale
7 D = np . random . rand (2 , 3) # A l a t o i r e - distribution uniforme
8 E = np . random . randint (0 , 10 , [2 , 3]) # Entiers a l a t o i r e s
9
10 A = np . ones ((2 , 3) , dtype = np . float16 ) # Type m m o i r e d f i n i
11 B = np . eye (4 , dtype = np . bool_ ) # Matrice i d e n t i t bool enne
12
13 A = np . linspace (1 , 10 , 10) # quivalent de range avec pas flottant
14 B = np . arange (0 , 20 , 10) # Tableau de valeurs r g u l i r e s

Listing 50 – Création de tableaux avec NumPy

Explication

Les fonctions de création de tableaux sont très pratiques pour générer rapidement des structures
de données : constantes (zeros, ones), aléatoires (randn, rand, randint) ou structurées (eye,
arange, linspace).

4.1.2 Attributs utiles


1 A = np . zeros ((4 , 3) )
2
3 print ( A . size ) # Nombre total d ’ lments
4 print ( A . shape ) # Dimensions du tableau ( tuple )
5 print ( type ( A . shape ) ) # Type tuple
6 print ( A . shape [0]) # Taille de la p r e m i r e dimension

Listing 51 – Accès aux attributs d’un tableau

Explication

Ces attributs permettent d’explorer la structure des tableaux NumPy. size donne le nombre total
d’éléments, shape donne les dimensions, et shape[0] est très utile pour connaître le nombre de
lignes dans un tableau 2D.

BDCC-S3-2024-2025 30 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.1.3 Méthodes importantes


1 A = np . zeros ((2 , 3) )
2 A = A . reshape ((3 , 2) ) # Redimensionnement
3 A . ravel () # Aplatir le tableau
4 A . squeeze () # Supprime les dimensions de taille 1
5
6 B = np . ones ((2 , 3) )
7 np . concatenate (( A , B ) , axis =0) # C o n c a t n a t i o n verticale
8 np . concatenate (( A , B ) , axis =1) # C o n c a t n a t i o n horizontale

Listing 52 – Manipulation de la forme d’un tableau

Explication

Les méthodes comme reshape, ravel et squeeze sont utiles pour adapter la forme des tableaux
selon les besoins du traitement. La fonction concatenate permet d’assembler plusieurs tableaux
le long d’un axe (lignes ou colonnes).

4.1.4 Initialisation personnalisée avec colonne de biais


1 def initia lisati on (m , n ) :
2 # m : nombre de lignes
3 # n : nombre de colonnes
4 # retourne une matrice a l a t o i r e (m , n +1)
5 # avec une colonne biais ( remplie de "1") tout droite
6 X = np . random . randn (m , n )
7 X = np . concatenate (( X , np . ones (( X . shape [0] , 1) ) ) , axis =1)
8 return X
9
10 X = in itiali sation (3 , 4)

Listing 53 – Fonction d’initialisation d’une matrice avec colonne biais

Explication

Cette fonction génère une matrice de taille (m, n+1) avec une colonne supplémentaire remplie de
1. Cette colonne de biais est très utilisée dans les modèles de Machine Learning, notamment pour
ajouter un biais dans les calculs linéaires.

4.1.5 Indexing et Slicing


1 import numpy as np
2
3 A = np . array ([[1 , 2 , 3] , [4 , 5 , 6]])
4 print ( A )
5
6 # Acc s l’ lment en ligne 0 , colonne 1
7 A [0 , 1]
8
9 # S l e c t i o n d ’ un bloc de lignes 0 1 et colonnes 0 1
10 A [0:2 , 0:2]
11
12 # Remplacement du bloc s l e c t i o n n par 10
13 A [0:2 , 0:2] = 10
14 print ( A )

Listing 54 – Indexing et slicing avec NumPy

BDCC-S3-2024-2025 31 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

L’indexation et le slicing dans NumPy fonctionnent comme avec les listes Python. On peut accéder
à un élément avec la notation A[i, j], et à un sous-tableau avec des tranches : A[i:j, k:l]. Il
est aussi possible d’assigner une valeur à une région entière du tableau.

4.1.6 Indexation booléenne


1 A = np . array ([[1 , 2 , 3] , [4 , 5 , 6]])
2
3 print ( A < 5) # C r e un masque b o o l e n
4 print ( A [ A < 5]) # Extrait les valeurs correspondant au masque
5 A [ A < 5] = 4 # Remplace les valeurs < 5 par 4
6 print ( A )

Listing 55 – Utilisation des masques booléens pour filtrer les données

Explication

L’indexation booléenne permet de sélectionner les éléments répondant à une condition. Ici, tous
les éléments inférieurs à 5 sont remplacés par 4. Très utile pour filtrer et modifier des données de
manière vectorisée.

4.1.7 Exercices avec solutions

Exercice 1 : Remplir les 4 blocs du milieu par des "1"

1 B = np . zeros ((4 , 4) )
2 B
3
4 # SOLUTION
5 B [1:3 , 1:3] = 1
6 B

Listing 56 – Remplir le centre d’un tableau

Explication

On utilise ici un slicing pour cibler les 4 cases centrales (lignes 1-2 et colonnes 1-2) et les remplir
avec des 1.

Exercice 2 : Remplir le tableau de "1" une ligne sur deux, une colonne sur deux

1 C = np . zeros ((5 , 5) )
2 C
3
4 # SOLUTION
5 C [::2 , ::2] = 1
6 C

Listing 57 – Remplir une grille en damier avec des "1"

Explication

Avec le slicing ::2, on sélectionne une ligne sur deux et une colonne sur deux. Cela crée un motif
en damier.

Exercice 3 : Sur une image, ne garder que le centre et remplacer les pixels > 150 par 255

BDCC-S3-2024-2025 32 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 from scipy import misc
2 import matplotlib . pyplot as plt
3
4 face = misc . face ( gray = True ) # Image en niveaux de gris
5 plt . imshow ( face , cmap = plt . cm . gray )
6 plt . show ()
7
8 face . shape # Dimensions de l image
9
10 # SOLUTION
11 x , y = face . shape
12 zoom_face = face [ x //4 : -x //4 , y //4 : -y //4] # Zoom au centre
13 zoom_face [ zoom_face > 150] = 255 # Pixels >150 deviennent blancs
14
15 plt . imshow ( zoom_face , cmap = plt . cm . gray )
16 plt . show ()

Listing 58 – Zoom et modification de pixels dans une image

Explication

Cet exercice combine le slicing et l’indexation booléenne sur des images. On extrait le centre de
l’image puis on transforme les pixels les plus clairs (valeurs >150) en blanc pur (255).

Relation entre l’écart-type et la variance

L’écart-type (σ) est la racine carrée de la variance (σ 2 ) :
√
σ = σ2
Population complète :
v
N u N
1 X u1 X
σ2 = (xi − µ)2 et σ = t (xi − µ)2
N i=1 N i=1

Échantillon : v
n u n
1 X 1 X
et s = t
u
s2 = (xi − x̄)2 (xi − x̄)2
n−1 i=1
n − 1 i=1

Exemple : données = {4, 7, 10, 13, 16}

4 + 7 + 10 + 13 + 16
µ= = 10
5

(4 − 10)2 + (7 − 10)2 + (10 − 10)2 + (13 − 10)2 + (16 − 10)2

σ2 = = 18
5
√
σ = 18 ≈ 4,243

Exemples de méthodes NumPy


1 import numpy as np
2
3 A = np . array ([[1 , 2 , 3] , [4 , 5 , 6]])

Ce tableau A contient deux lignes et trois colonnes.


1 print ( A . sum () )

BDCC-S3-2024-2025 33 Mohamed Ouazze

4 BIBLIOTHÈQUES ESSENTIELLES

Figure 3 – image

BDCC-S3-2024-2025 34 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Calcule la somme de tous les éléments du tableau.


1 print ( A . sum ( axis =0) )

Calcule la somme des éléments colonne par colonne.


1 print ( A . sum ( axis =1) )

Calcule la somme des éléments ligne par ligne.


1 print ( A . cumsum ( axis =0) )

Effectue la somme cumulée sur les lignes.


1 print ( A . prod () )
2 print ( A . cumprod () )

prod() calcule le produit total, cumprod() effectue le produit cumulatif.


1 print ( A . min () )
2 print ( A . max () )

Trouve respectivement le minimum et le maximum du tableau.


1 print ( A . mean () )
2 print ( A . std () )
3 print ( A . var () )

Calcule respectivement la moyenne, l’écart-type et la variance du tableau.

Méthode argsort()

1 A = np . random . randint (0 , 10 , [5 , 5])
2 print ( A )
3 print ( A . argsort () )
4 print ( A [: ,0]. argsort () )
5 A = A [ A [: ,0]. argsort () , :]
6 print ( A )

Génère une matrice aléatoire 5x5, trie chaque ligne, puis trie la matrice entière selon la première colonne.

4.2 Statistiques NumPy

Corrélation de Pearson

1 B = np . random . randn (3 , 3)
2 print ( np . corrcoef ( B ) )
3 print ( np . corrcoef ( B [: ,0] , B [: , 1]) )

Calcule la matrice de corrélation pour les lignes et une corrélation spécifique entre deux colonnes.

BDCC-S3-2024-2025 35 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Valeurs uniques et fréquences


1 np . random . seed (0)
2 A = np . random . randint (0 , 10 , [5 ,5])
3 values , counts = np . unique (A , return_counts = True )
4
5 for i , j in zip ( values [ counts . argsort () ] , counts [ counts . argsort () ]) :
6 print ( f ’ valeur { i } apparait { j } ’)

Affiche les valeurs uniques dans la matrice et leur fréquence triée.

Traitement des NaN


1 A = np . random . randn (5 , 5)
2 A [0 , 2] = np . nan
3 print ( ’ ratio NaN / size : ’ , ( np . isnan ( A ) . sum () / A . size ) )
4 print ( ’ moyenne sans NaN : ’ , np . nanmean ( A ) )

Insère un NaN, calcule la proportion de NaN et la moyenne sans les prendre en compte.

4.3 Opérations linéaires


1 A = np . ones ((2 ,3) )
2 B = np . ones ((3 ,3) )
3 print ( A . T )
4 print ( A . dot ( B ) )

Transpose la matrice A et effectue le produit matriciel A · B.


1 A = np . random . randint (0 , 10 , [3 , 3])
2 print ( ’ det = ’ , np . linalg . det ( A ) )
3 print ( ’ inv A :\ n ’ , np . linalg . inv ( A ) )
4 val , vec = np . linalg . eig ( A )
5 print ( ’ valeur propre :\ n ’ , val )
6 print ( ’ vecteur propre :\ n ’ , vec )

Calcule le déterminant, l’inverse, les valeurs propres et les vecteurs propres d’une matrice.

4.4 Exercice : Standardisation de matrice

Objectif : standardiser chaque colonne (moyenne 0, écart-type 1)

1 np . random . seed (0)
2 A = np . random . randint (0 , 100 , [10 , 5])
3 print ( " Matrice originale :\ n " , A )
4
5 D = ( A - A . mean ( axis =0) ) / A . std ( axis =0)
6 print ( " Matrice s t a n d a r d i s e :\ n " , D )
7
8 print ( " Moyennes colonnes : " , D . mean ( axis =0) )
9 print ( " carts - types colonnes : " , D . std ( axis =0) )

On standardise la matrice A en soustrayant la moyenne et divisant par l’écart-type de chaque colonne.

Le résultat D a une moyenne de 0 et un écart-type de 1 pour chaque colonne.

BDCC-S3-2024-2025 36 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.5 Numpy et Broadcasting

Une des façons dont Numpy optimise les calculs de tableaux est le broadcasting. Le broadcasting
permet d’effectuer des opérations sur des tableaux de différentes tailles de manière rapide et efficace, en
étendant les dimensions du tableau le plus petit pour le rendre compatible avec le plus grand. Ce processus
est utilisé, par exemple, lorsque l’on travaille avec des tableaux de dimensions différentes, mais où les
éléments peuvent être alignés pour les opérations. Le broadcasting peut être illustré par des exemples
comme suit :

1 import numpy as np
2
3 # Exemple 1 : Broadcasting d ’ un scalaire avec un tableau
4 A = np . ones ((2 , 3) ) # Un tableau 2 x3 de 1
5 B = 3 # Un scalaire
6 print ( A + B ) # R s u l t a t : chaque lment de A est a d d i t i o n n avec B

Explication

Dans ce premier exemple, nous ajoutons un scalaire à un tableau 2x3. Le broadcasting s’applique
ici, où le scalaire 3 est "étendu" sur chaque élément du tableau A, résultant en un tableau où
chaque élément est augmenté de 3. Le résultat est donc un tableau 2 × 3 de 4.

BDCC-S3-2024-2025 37 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # Exemple 2 : Broadcasting d ’ un tableau avec un tableau ayant des dimensions compatibles
2 A = np . ones ((2 , 3) ) # Un tableau 2 x3 de 1
3 B = np . ones ((2 , 1) ) # Un tableau 2 x1 de 1 , sera tendu sur 3 colonnes
4 print ( A + B ) # R s u l t a t : chaque colonne de B est tendue sur A

Explication

Dans ce deuxième exemple, le tableau B a une dimension 2 × 1, ce qui signifie qu’il n’a qu’une
colonne. Ce tableau sera étendu sur les trois colonnes de A. Par conséquent, chaque élément de la
colonne de B sera ajouté à chaque colonne correspondante de A, produisant un tableau 2 × 3 de
2.

1 # Exemple 3 : Broadcasting d ’ un tableau 2 x2 avec un tableau 2 x3
2 A = np . ones ((2 , 3) ) # Un tableau 2 x3 de 1
3 B = np . ones ((2 , 2) ) # Un tableau 2 x2 de 1
4 print ( A + B ) # R s u l t a t s non compatibles , va lever une erreur

Explication

Dans ce troisième exemple, nous tentons d’ajouter deux tableaux A de dimension 2 × 3 et B de

dimension 2 × 2. Ici, le broadcasting échoue car les dimensions ne sont pas compatibles. Le nombre
de colonnes de A (3) ne correspond pas au nombre de colonnes de B (2), et donc cette opération
lèvera une erreur.

4.6 Matplotlib : Graphiques de Base

Pyplot

1 import numpy as np
2 import matplotlib . pyplot as plt
3
4 # Graphiques simples
5 X = np . linspace (0 , 2 , 10)
6 y = X **2
7
8 plt . plot (X , y )
9 plt . show ()

Figure 4 – Exemple de graphique simple montrant une courbe quadratique.

Explication

Ce graphique montre une courbe représentant la relation quadratique entre X et y = X 2 . La

fonction np.linspace génère 10 points également espacés entre 0 et 2, et la fonction plt.plot
trace la courbe.

BDCC-S3-2024-2025 38 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 plt . scatter (X , y )
2 plt . show ()

Figure 5 – Exemple de graphique scatter montrant des points sur la courbe.

Explication

Ce graphique montre les points individuels de la courbe en utilisant un graphique de type scatter.
Chaque point est représenté par une marque individuelle sans ligne reliant les points.

Styles Graphiques Il existe plusieurs styles à ajouter aux graphiques. Voici les plus importants à
retenir :
— c : couleur de la ligne
— lw : épaisseur de la ligne (pour les graphiques plot)
— ls : style de la ligne (pour les graphiques plot)
— size : taille du point (pour les graphiques scatter)
— marker : style des points (pour les graphiques scatter)
— alpha : transparence du graphique

1 plt . plot (X , y , c = ’ red ’ , lw =4 , ls = ’ -- ’ , alpha =0.8)
2 plt . show ()

Figure 6 – Graphique avec des styles personnalisés : ligne rouge, épaisseur de 4, et ligne en pointillé.

Explication

Ce graphique applique plusieurs styles à la courbe. La couleur de la ligne est rouge, l’épaisseur de
la ligne est définie à 4, le style de la ligne est pointillé, et la transparence de la ligne est réduite à
80% avec alpha=0.8.

BDCC-S3-2024-2025 39 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Cycle de vie d’une figure Pour créer des figures proprement, on doit suivre le cycle de vie suivant :

1 plt . figure ( figsize =(8 , 6) ) # Taille de la figure
2 plt . plot (X , X **2 , label = ’ quadratique ’) # Premier graphique
3 plt . plot (X , X **3 , label = ’ cubique ’) # D e u x i m e graphique
4 # Information s u p p l m e n t a i r e
5 plt . title ( ’ figure 1 ’) # Titre
6 plt . xlabel ( ’ axe x ’) # L g e n d e de l ’ axe x
7 plt . ylabel ( ’ axe y ’) # L g e n d e de l ’ axe y
8 plt . legend () # L g e n d e des courbes
9
10 plt . savefig ( ’ figure . png ’) # Sauvegarde la figure dans le r p e r t o i r e de travail
11 plt . show () # Affiche la figure

Figure 7 – Exemple de figure avec deux courbes : une quadratique et une cubique.

Explication

Ce graphique montre deux courbes, une quadratique et une cubique, sur la même figure. Nous
avons ajouté des titres et des légendes aux axes pour rendre le graphique plus lisible. Enfin, nous
avons sauvegardé l’image sous le nom figure.png.

Subplots Les subplots sont utilisés pour afficher plusieurs graphiques sur une même figure.

1 plt . subplot (2 , 1 , 1) # Premier subplot (2 lignes , 1 colonne , premier graphique )
2 plt . plot (X , X **2 , c = ’ red ’)
3 plt . subplot (2 , 1 , 2) # D e u x i m e subplot (2 lignes , 1 colonne , d e u x i m e graphique )
4 plt . plot (X , X **3 , c = ’ blue ’)
5 plt . show ()

Figure 8 – Exemple de subplots montrant deux graphiques sur une même figure.

BDCC-S3-2024-2025 40 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Ici, deux sous-graphiques sont créés sur une figure en utilisant la fonction subplot. Le premier
graphique montre la courbe quadratique, et le deuxième montre la courbe cubique. Les subplots
sont disposés verticalement avec 2, 1 dans subplot.

Méthode orientée objet Voici un exemple de création de subplots en utilisant la méthode orientée
objet.

1 fig , ax = plt . subplots (2 , 1 , sharex = True ) # Partage le m m e axe x pour les subplots
2 ax [0]. plot (X , X **2 , label = ’ quadratique ’)
3 ax [1]. plot (X , np . sin ( X ) , label = ’ sinus ’)
4 plt . show ()

Figure 9 – Exemple de graphique utilisant la méthode orientée objet avec deux subplots partageant le
même axe.

Explication

Cet exemple montre l’utilisation de la méthode orientée objet avec fig et ax pour créer deux
subplots. Les deux courbes partagent le même axe x, ce qui permet de mieux comparer les deux
graphiques.

Exercice et Solution Créez une fonction graphique qui permet de tracer sur une seule et même figure
une série de graphiques issue d’un dictionnaire contenant plusieurs datasets :

1 def graphique ( dataset ) :
2 for label , data in dataset . items () :
3 plt . plot ( data , label = label )
4 plt . legend ()
5 plt . show ()
6
7 # Voici le dataset u t i l i s
8 dataset = { f " experience { i } " : np . random . randn (100) for i in range (4) }
9 graphique ( dataset )

Figure 10 – Exemple d’un graphique généré à partir d’un dictionnaire de datasets.

BDCC-S3-2024-2025 41 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Cette fonction graphique prend un dictionnaire où chaque clé représente un label et chaque valeur
est un dataset. Elle trace chaque dataset sur la même figure, et ajoute une légende pour chaque
courbe.

4.7 Matplotlib : Top Graphiques

— Les types de graphiques ci-dessous représentent des cas d’usage fréquents en data science et per-
mettent une meilleure compréhension des données.

4.7.1 Graphique de Classification avec Scatter()


1 from sklearn . datasets import load_iris
2 import matplotlib . pyplot as plt
3 import numpy as np
4
5 iris = load_iris ()
6 x = iris . data
7 y = iris . target
8
9 print ( f ’x contient { x . shape [0]} exmples et { x . shape [1]} variables ’)
10 print ( f ’ il y a { np . unique ( y ) . size } classes ’)
11
12 n = x . shape [1]
13 plt . figure ( figsize =(12 , 8) )
14 for i in range ( n ) :
15 plt . subplot ( n //2 , n //2 , i +1)
16 plt . scatter ( x [: , 0] , x [: , i ] , c = y )
17 plt . xlabel ( ’0 ’)
18 plt . ylabel ( i )
19 plt . colorbar ( ticks = list ( np . unique ( y ) ) )
20 plt . show ()

Explication

Ce graphique permet de visualiser la relation entre la première variable (x[ :, 0]) et toutes les
autres, colorées par classe. Cela aide à détecter les séparabilités visuelles.

Figure 11 – Classification avec Scatter

BDCC-S3-2024-2025 42 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.7.2 Graphiques 3D

1 from mpl_toolkits . mplot3d import Axes3D
2
3 ax = plt . axes ( projection = ’3 d ’)
4 ax . scatter ( x [: , 0] , x [: , 1] , x [: ,2] , c = y )

Figure 12 – Graphiques 3D avec Scatter

Explication

Affiche les données dans un espace 3D, utile pour visualiser les relations entre 3 variables.


1 f = lambda x , y : np . sin ( x ) + np . cos ( x + y )
2
3 X = np . linspace (0 , 5 , 50)
4 Y = np . linspace (0 , 5 , 50)
5 X , Y = np . meshgrid (X , Y )
6 Z = f (X , Y )
7
8 ax = plt . axes ( projection = ’3 d ’)
9 ax . plot_surface (X , Y , Z , cmap = ’ plasma ’)
10 plt . show ()

Explication

Trace une surface 3D définie par une fonction mathématique. Cela est utile pour l’analyse de
surfaces continues.

Figure 13 – Graphiques 3D avec Surface

BDCC-S3-2024-2025 43 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.8 Histogrammes

1 x = np . random . randn (1000)
2
3 plt . figure ( figsize =(12 , 3) )
4 plt . subplot (121)
5 plt . hist (x , bins =10)
6 plt . title ( ’ bins =10 ’)
7 plt . subplot (122)
8 plt . hist (x , bins =50)
9 plt . title ( ’ bins = 50 ’)
10 plt . show ()

Explication

Permet de visualiser la distribution d’un jeu de données en ajustant le nombre de classes (bins).

Figure 14 – Histogrammes avec différentes tailles de bins


1 x = iris . data
2 plt . hist2d ( x [: ,0] , x [: ,1] , cmap = ’ Blues ’)
3 plt . xlabel ( ’ longueur s p a l ’)
4 plt . ylabel ( ’ largeur s p a l ’)
5 plt . colorbar ()

Explication

Histogramme 2D pour analyser la densité conjointe de deux variables.

Figure 15 – Histogramme d’une image

BDCC-S3-2024-2025 44 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 from scipy import misc
2 face = misc . face ( gray = True )
3
4 plt . figure ( figsize =(12 , 4) )
5 plt . subplot (121)
6 plt . imshow ( face , cmap = ’ gray ’)
7 plt . subplot (122)
8 plt . hist ( face . ravel () , bins =255)
9 plt . show ()

Explication

Histogramme d’une image pour analyser l’intensité des niveaux de gris.

Figure 16 – Histogramme d’une image

4.9 Graphiques ContourPlot()


1 f = lambda x , y : np . sin ( x ) + np . cos ( x + y ) * np . cos ( x )
2
3 X = np . linspace (0 , 5 , 50)
4 Y = np . linspace (0 , 5 , 50)
5 X , Y = np . meshgrid (X , Y )
6 Z = f (X , Y )
7
8 plt . contour (X , Y , Z , 20 , colors = ’ black ’)
9 plt . contourf (X , Y , Z , 20 , cmap = ’ RdGy ’)
10 plt . colorbar ()

Explication

Les courbes de niveau (contours) représentent les lignes de même valeur d’une fonction 2D. Utile
pour l’analyse topographique ou de champs scalaires.

Figure 17 – Contours et zones colorées

BDCC-S3-2024-2025 45 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.9.1 Imshow()

1 plt . figure ( figsize =(12 , 3) )
2
3 X = np . random . randn (50 , 50)
4 plt . subplot (131)
5 plt . imshow ( X )
6 plt . title ( ’ random normal ’)
7
8 from sklearn . datasets import load_iris
9 iris = load_iris ()
10 X = iris . data
11 y = iris . target
12
13 plt . subplot (132)
14 plt . imshow ( np . corrcoef ( X .T , y ) )
15 plt . title ( ’ Iris C o r r l a t i o n ’)
16
17 X = np . linspace (0 , 5 , 100)
18 Y = np . linspace (0 , 5 , 100)
19 X , Y = np . meshgrid (X , Y )
20 f = lambda x , y : np . sin ( x ) + np . cos ( y )
21
22 plt . subplot (133)
23 plt . imshow ( f (X , Y ) )
24 plt . colorbar ()
25 plt . title ( ’f (x , y ) = sin ( x ) + cos ( y ) ’)

Explication

imshow() affiche une matrice comme une image. Très utile pour visualiser des matrices de corré-
lation, des fonctions ou des images brutes.

Figure 18 – Visualisations avec imshow()

4.10 Machine Learning avec SciPy

SciPy contient des modules très puissants pour le machine learning, l’analyse de données, les séries
temporelles, etc. Ce document vous montre quelques-unes des fonctions les plus utiles.

1 import numpy as np
2 import matplotlib . pyplot as plt

Listing 59 – Importation des bibliothèques

4.10.1 Interpolation
Interpoler un signal est parfois très utile s’il vous manque des données dans un Dataset. Mais c’est
une technique dangereuse, qui peut parfois transformer la réalité des choses !

BDCC-S3-2024-2025 46 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # C r a t i o n d ’ un Dataset
2 x = np . linspace (0 , 10 , 10)
3 y = np . sin ( x )
4 plt . scatter (x , y )

Listing 60 – Création d’un dataset simple

Explication

Cette partie crée un jeu de données simple avec 10 points répartis uniformément entre 0 et 10,
et calcule le sinus de ces valeurs. Le résultat est affiché sous forme de points dispersés avec
plt.scatter().

Figure 19 – Visualisation des points d’échantillonnage


1 from scipy . interpolate import interp1d
2
3 # c r a t i o n de la fonction interpolation f
4 f = interp1d (x , y , kind = ’ cubic ’)
5
6 # r s u l t a t s de la fonction interpolation f sur de nouvelles d o n n e s
7 new_x = np . linspace (0 , 10 , 50)
8 result = f ( new_x )
9
10 # visualisation avec matplotlib
11 plt . scatter (x , y )
12 plt . plot ( new_x , result , c = ’r ’)

Listing 61 – Interpolation avec scipy.interpolate

Explication

La fonction interp1d de SciPy permet de créer une fonction d’interpolation à partir de points
discrets. Le paramètre kind=’cubic’ spécifie une interpolation cubique qui génère une courbe
lisse passant par tous les points originaux. Cette technique est particulièrement utile pour estimer
des valeurs entre des points connus ou pour reconstruire un signal continu à partir d’échantillons.

BDCC-S3-2024-2025 47 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 20 – Interpolation 1D avec méthode cubique

4.10.2 Optimisation
On trouve beaucoup de fonctions dans le module optimize. Certaines permettent de faire des mini-
misations locales ou globales, d’autres permettent de développer des modèles statistiques avec la méthode
des moindres carrés. On trouve également des fonctions pour faire de la programmation linéaire.

4.10.3 curve_fit

1 # C r a t i o n d ’ un Dataset avec du bruit " normal "
2 x = np . linspace (0 , 2 , 100)
3 y = 1/3* x **3 - 3/5 * x **2 + 2 + np . random . randn ( x . shape [0]) /20
4 plt . scatter (x , y )

Listing 62 – Création d’un dataset avec bruit

Explication

Ici, nous créons un ensemble de données qui suit une fonction polynomiale de degré 3 avec un
bruit gaussien ajouté. Le bruit est divisé par 20 pour le réduire et rendre la tendance principale
plus visible. Ce type de dataset est courant dans les problèmes d’ajustement de courbe.

Figure 21 – Dataset avec bruit normal

BDCC-S3-2024-2025 48 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # D f i n i t i o n d ’ un m o d l e statistique s e n s " coller " au dataset ci - dessus
2 def f (x , a , b , c , d ) :
3 return a * x **3 + b * x **2 + c * x + d
4
5 from scipy import optimize
6
7 # curve_fit permet de trouver les p a r a m t r e s du m o d l e f g r c e la m t h o d e des
moindres c a r r s
8 params , param_cov = optimize . curve_fit (f , x , y )
9
10 # Visualisation des r s u l t a t s
11 plt . scatter (x , y )
12 plt . plot (x , f (x , params [0] , params [1] , params [2] , params [3]) , c = ’g ’ , lw =3)

Listing 63 – Ajustement de courbe avec curvef it

Explication

La fonction curve_fit permet d’ajuster un modèle mathématique à des données. Elle utilise
la méthode des moindres carrés pour trouver les paramètres optimaux qui minimisent l’erreur
quadratique entre les prédictions du modèle et les données observées. Dans cet exemple, nous
ajustons un polynôme de degré 3 aux données bruitées. Le résultat params contient les coefficients
optimaux du polynôme, tandis que param_cov donne la matrice de covariance des paramètres,
utile pour estimer leur incertitude.

Figure 22 – Modèle ajusté par la méthode des moindres carrés

4.10.4 Minimisation 1D
La fonction optimize.minimize est utile pour trouver un minimum local dans une fonction à N
dimensions.

1 # D f i n i t i o n d ’ une fonction 1 Dimension
2 def f ( x ) :
3 return x **2 + 15* np . sin ( x )
4
5 # Visualisation de la fonction
6 x = np . linspace ( -10 , 10 , 100)
7 plt . plot (x , f ( x ) )

Listing 64 – Définition d’une fonction 1D

BDCC-S3-2024-2025 49 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Nous définissons une fonction 1D qui combine un terme quadratique et un terme sinusoïdal,
créant ainsi plusieurs minima locaux. Ce type de fonction est un bon exemple pour illustrer les
algorithmes d’optimisation.

Figure 23 – Visualisation de la fonction à minimiser


1 # D f i n i t i o n d ’ un point x0 pour l ’ algorithme de minimisation
2 x0 = -5
3 result = optimize . minimize (f , x0 = x0 ) . x # r s u l t a t de la minimisation
4
5 # Visualisation du r s u l t a t
6 plt . plot (x , f ( x ) , lw =3 , zorder = -1) # Courbe de la fonction
7 plt . scatter ( x0 , f ( x0 ) , s =200 , marker = ’+ ’ , c = ’g ’ , zorder =1 , label = ’ initial ’) # point
initial
8 plt . scatter ( result , f ( result ) , s =100 , c = ’r ’ , zorder =1 , label = ’ final ’) # point final
9 plt . legend ()
10 plt . show ()

Listing 65 – Minimisation d’une fonction 1D

Explication

La fonction optimize.minimize prend en entrée la fonction à minimiser et un point de départ

x0. À partir de ce point, l’algorithme cherche itérativement le minimum local le plus proche. Le
choix du point de départ est crucial car il détermine vers quel minimum l’algorithme va converger
lorsque la fonction possède plusieurs minima locaux. Cette visualisation montre clairement le point
initial et le résultat final trouvé par l’algorithme.

Figure 24 – Résultat de la minimisation 1D

BDCC-S3-2024-2025 50 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.10.5 Minimisation 2D

1 # D f i n i t i o n d ’ une fonction 2 D . X est un tableau numpy 2 - Dimensions
2 def f ( x ) :
3 return np . sin ( x [0]) + np . cos ( x [0]+ x [1]) * np . cos ( x [0])
4
5 # G n r a t i o n de la fonction sur un espace 2 D
6 x = np . linspace ( -3 , 3 , 100)
7 y = np . linspace ( -3 , 3 , 100)
8 x , y = np . meshgrid (x , y )
9
10 # Visualisation de la fonction
11 plt . contour (x , y , f ( np . array ([ x , y ]) ) , 20)

Listing 66 – Définition d’une fonction 2D

Explication

Ici, nous définissons une fonction à deux variables pour illustrer la minimisation multidimension-
nelle. La fonction meshgrid permet de créer une grille 2D pour évaluer notre fonction sur tout un
domaine. La visualisation par courbes de niveau (contour) nous permet d’identifier visuellement
les bassins d’attraction et les minima locaux.

Figure 25 – Visualisation de la fonction 2D par courbes de niveau


1 # Placement d ’ un point x0 initial aux c o o r d o n n e s (0 ,0)
2 x0 = np . zeros (2)
3
4 # Minimisation de la fonction
5 result = optimize . minimize (f , x0 = x0 ) . x
6 print ( ’ le minimum est aux c o o r d o n n e s ’ , result ) # imprimer le r s u l t a t
7
8 # Visualisation du r s u l t a t
9 plt . contour (x , y , f ( np . array ([ x , y ]) ) , 20) # fonction 2 D
10 plt . scatter ( x0 [0] , x0 [1] , marker = ’+ ’ , c = ’r ’ , s =100 , label = ’ initial ’) # Point de d p a r t
11 plt . scatter ( result [0] , result [1] , c = ’g ’ , s =100 , label = ’ final ’) # Point final
12 plt . legend ()
13 plt . show ()

Listing 67 – Minimisation d’une fonction 2D

BDCC-S3-2024-2025 51 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Pour la minimisation 2D, le principe est similaire à la minimisation 1D, mais le point initial x0 et
le résultat sont maintenant des vecteurs à 2 dimensions. La fonction optimize.minimize utilise
par défaut la méthode BFGS (Broyden-Fletcher-Goldfarb-Shanno), un algorithme d’optimisation
quasi-newtonien qui approxime le Hessien de la fonction pour trouver efficacement le minimum
local. La visualisation montre le chemin entre le point initial et le minimum local trouvé.

Figure 26 – Résultat de la minimisation 2D

4.11 Traitement du signal

Le module scipy.signal contient beaucoup de fonctions de convolution et de filtres pour faire du
traitement du signal. La fonction signal.detrend est parfaite pour éliminer une tendance linéaire dans
un signal. Le module scipy.fftpack contient des fonctions très puissantes et simples d’utilisation pour
effectuer des transformations de Fourier.

1 # C r a t i o n d ’ un Dataset avec une tendance l i n a i r e
2 x = np . linspace (0 , 20 , 100)
3 y = x + 4* np . sin ( x ) + np . random . randn ( x . shape [0])
4 plt . plot (x , y )

Listing 68 – Création d’un signal avec tendance linéaire

Explication

Ici, nous créons un signal qui combine une tendance linéaire (x), une composante sinusoïdale
(4*np.sin(x)) et un bruit aléatoire. Ce type de signal est courant dans de nombreuses applications
scientifiques où une tendance à long terme peut masquer des oscillations d’intérêt.

BDCC-S3-2024-2025 52 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 27 – Signal avec tendance linéaire


1 from scipy import signal
2
3 # limination de la tendance l i n a i r e
4 new_y = signal . detrend ( y )
5
6 # Visualisation des r s u l t a t s
7 plt . plot (x , y , label = ’ originel ’)
8 plt . plot (x , new_y , label = ’ detrend ’)
9 plt . legend ()
10 plt . show ()

Listing 69 – Suppression de la tendance linéaire

Explication

La fonction signal.detrend supprime automatiquement la composante linéaire d’un signal. Cette

opération est souvent une étape de prétraitement essentielle dans l’analyse de signaux, car elle per-
met de mettre en évidence les oscillations et les motifs qui pourraient être masqués par la tendance
générale. Après avoir retiré la tendance, les variations sinusoïdales et le bruit deviennent plus vi-
sibles, ce qui facilite leur analyse. Cette technique est particulièrement utile en traitement de séries
temporelles, en climatologie, en économétrie et dans de nombreux autres domaines scientifiques.

Figure 28 – Comparaison du signal original et du signal sans tendance

BDCC-S3-2024-2025 53 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.12 Transformation de Fourier (FFT)

Le module scipy.fftpack contient des fonctions pour effectuer des transformations de Fourier de
manière simple et efficace. Cette technique mathématique permet d’analyser les fréquences qui composent
un signal périodique.

1 # C r a t i o n d ’ un signal p r i o d i q u e n o y dans du bruit
2 x = np . linspace (0 , 30 , 1000)
3 y = 3* np . sin ( x ) + 2* np . sin (5* x ) + np . sin (10* x ) + np . random . random ( x . shape [0]) *10
4 plt . plot (x , y )
5 plt . title ( " Signal p r i o d i q u e avec bruit " )
6 plt . xlabel ( " Temps " )
7 plt . ylabel ( " Amplitude " )
8 plt . show ()

Listing 70 – Création d’un signal périodique avec bruit

Explication

Nous générons ici un signal composé de trois ondes sinusoïdales de fréquences différentes (1, 5 et
10), auquel nous ajoutons un bruit aléatoire d’amplitude maximale 10. Ce type de signal représente
un cas classique où la transformation de Fourier permet d’extraire les composantes périodiques
cachées dans un signal bruité.

Figure 29 – Signal périodique avec bruit aléatoire


1 from scipy import fftpack
2
3 # C r a t i o n des variables Fourier et F r q u e n c e s pour construire le spectre du signal
4 fourier = fftpack . fft ( y )
5 power = np . abs ( fourier ) # limination des amplitudes n g a t i v e s
6 frequences = fftpack . fftfreq ( y . size )
7
8 # Visualisation du spectre
9 plt . plot ( np . abs ( frequences ) , power )
10 plt . title ( " Spectre du signal " )
11 plt . xlabel ( " F r q u e n c e " )
12 plt . ylabel ( " Amplitude " )
13 plt . show ()

Listing 71 – Analyse spectrale par FFT

BDCC-S3-2024-2025 54 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

La transformation de Fourier fftpack.fft() convertit notre signal du domaine temporel au do-

maine fréquentiel. La fonction fftpack.fftfreq() génère les valeurs de fréquence correspondant
à chaque point du spectre. La variable power représente l’amplitude de chaque composante fré-
quentielle, obtenue en prenant la valeur absolue du résultat de la FFT. Le spectre résultant montre
clairement les trois pics correspondant aux fréquences des sinusoïdes que nous avons utilisées pour
générer le signal.

Figure 30 – Spectre fréquentiel du signal


1 # Filtrage du spectre avec du boolean indexing de Numpy
2 fourier [ power <400] = 0
3
4 # Visualisation du spectre f i l t r
5 plt . plot ( np . abs ( frequences ) , np . abs ( fourier ) )
6 plt . title ( " Spectre f i l t r " )
7 plt . xlabel ( " F r q u e n c e " )
8 plt . ylabel ( " Amplitude " )
9 plt . show ()

Listing 72 – Filtrage spectral

Explication

Le filtrage spectral est réalisé en éliminant les composantes fréquentielles dont l’amplitude est
inférieure à un certain seuil (ici 400). Cette technique, appelée seuillage, permet d’éliminer le
bruit de faible amplitude tout en conservant les principales composantes du signal. La puissance
de l’indexation booléenne de NumPy rend cette opération extrêmement concise et efficace.

Figure 31 – Spectre après filtrage des composantes de faible amplitude

BDCC-S3-2024-2025 55 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # Trans format ion de Fourier inverse : g n r e un nouveau signal temporel depuis le
spectre f i l t r
2 f il te r ed _s i gn a l = fftpack . ifft ( fourier )
3
4 # Visualisation des r s u l t a t s
5 plt . figure ( figsize =(12 , 8) )
6 plt . plot (x , y , lw =0.5 , label = ’ signal originel ’)
7 plt . plot (x , filtered_signal , lw =3 , label = ’ signal f i l t r ’)
8 plt . legend ()
9 plt . title ( " Comparaison du signal original et f i l t r " )
10 plt . xlabel ( " Temps " )
11 plt . ylabel ( " Amplitude " )
12 plt . show ()

Listing 73 – Reconstruction du signal filtré

Explication

La fonction fftpack.ifft() effectue la transformation de Fourier inverse, convertissant notre

spectre filtré en un signal temporel. Le résultat est un signal nettoyé qui conserve principalement
les composantes sinusoïdales d’origine, avec une réduction significative du bruit. Cette technique de
débruitage est largement utilisée dans le traitement du signal, l’acoustique, les télécommunications
et de nombreux autres domaines où l’extraction de signaux périodiques à partir de données bruitées
est nécessaire.

Figure 32 – Comparaison entre le signal original bruité et le signal reconstruit après filtrage

BDCC-S3-2024-2025 56 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.13 Traitement d’images

Le module scipy.ndimage propose de nombreuses fonctions pour le traitement d’images, incluant des
convolutions, des filtres gaussiens, des méthodes de mesure et des opérations morphologiques.

1 from scipy import ndimage
2
3 # C r a t i o n d ’ une image avec quelques artefacts
4 np . random . seed (0)
5 X = np . zeros ((32 , 32) )
6 X [10: -10 , 10: -10] = 1
7 X [ np . random . randint (0 ,32 ,30) , np . random . randint (0 ,32 ,30) ] = 1 # ajout d ’ artefacts
al atoires
8
9 plt . imshow ( X )
10 plt . title ( " Image originale avec artefacts " )
11 plt . colorbar ()
12 plt . show ()

Listing 74 – Création d’une image avec artefacts

Explication

Nous créons ici une image binaire simple avec un carré blanc au centre et des artefacts aléatoires
(pixels blancs) dispersés dans l’image. Cette situation est analogue à une image contenant du bruit
de type "sel et poivre", un problème courant en traitement d’images.

Figure 33 – Image binaire avec artefacts aléatoires


1 # O p r a t i o n de b inary_ openin g = rosion puis dilation
2 open_X = ndimage . binary _openi ng ( X )
3
4 plt . imshow ( open_X )
5 plt . title ( " Image a p r s nettoyage morphologique " )
6 plt . colorbar ()
7 plt . show ()

Listing 75 – Opération morphologique de nettoyage

BDCC-S3-2024-2025 57 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

L’opération de binary_opening est une combinaison séquentielle d’une érosion suivie d’une dila-
tation. L’érosion élimine les pixels isolés et réduit les formes, tandis que la dilatation agrandit les
formes restantes. Cette opération est particulièrement efficace pour éliminer les petits artefacts
ou bruits tout en préservant les structures principales de l’image. Dans notre exemple, les pixels
blancs isolés sont supprimés, mais le carré central est préservé.

Figure 34 – Image après opération morphologique de nettoyage

4.14 Application : Traitement d’images (cas réel)

Dans cette section, nous appliquons les techniques de traitement d’images à un cas réel d’analyse de
bactéries.

1 # Importer l ’ image avec pyplot
2 image = plt . imread ( ’ bacteria . png ’)
3 image = image [: ,: ,0] # r d u i r e l ’ image en 2 D
4
5 plt . imshow ( image , cmap = ’ gray ’) # afficher l ’ image
6 plt . title ( " Image originale des b a c t r i e s " )
7 plt . colorbar ()
8 plt . show ()
9
10 print ( f " Dimensions de l ’ image : { image . shape } " )

Listing 76 – Chargement et préparation de l’image

Explication

Nous chargeons une image de bactéries et la convertissons en niveaux de gris en ne conservant que
le premier canal de couleur. Cette préparation de l’image est une étape courante en traitement
d’images biologiques, où l’on s’intéresse principalement à l’intensité plutôt qu’à la couleur.

Figure 35 – Image originale de bactéries en niveaux de gris

BDCC-S3-2024-2025 58 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # Copie de l ’ image , puis c r a t i o n d ’ un histogramme
2 image_2 = np . copy ( image )
3 plt . hist ( image_2 . ravel () , bins =255)
4 plt . title ( " Histogramme des i n t e n s i t s de pixels " )
5 plt . xlabel ( " I n t e n s i t " )
6 plt . ylabel ( " Nombre de pixels " )
7 plt . show ()

Listing 77 – Analyse de l’histogramme de l’image

Explication

L’histogramme nous permet d’analyser la distribution des intensités de pixels dans l’image. Cette
visualisation est cruciale pour déterminer un seuil approprié pour la binarisation de l’image. La
méthode ravel() transforme l’image 2D en un vecteur 1D, ce qui est nécessaire pour créer l’his-
togramme.

Figure 36 – Histogramme des intensités de pixels de l’image


1 # Boolean indexing : c r a t i o n d ’ une image binaire
2 image = image < 0.6
3
4 plt . imshow ( image )
5 plt . title ( " Image b i n a r i s e " )
6 plt . show ()

Listing 78 – Binarisation de l’image

Explication

La binarisation transforme notre image en niveaux de gris en une image binaire (noir et blanc) en
appliquant un seuil. Tous les pixels dont l’intensité est inférieure à 0.6 sont mis à True (blanc),
les autres à False (noir). Cette étape simplifie considérablement l’image et facilite l’identification
des objets d’intérêt, dans ce cas les bactéries.

Figure 37 – Image binarisée des bactéries

BDCC-S3-2024-2025 59 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # Morphologie u t i l i s e pour enlever les artefacts
2 open_image = ndimage . bina ry_ope ning ( image )
3
4 plt . imshow ( open_image )
5 plt . title ( " Image a p r s nettoyage morphologique " )
6 plt . show ()

Listing 79 – Nettoyage morphologique de l’image

Explication

Comme dans l’exemple précédent, nous utilisons l’opération d’ouverture binaire pour nettoyer
l’image des petits artefacts qui pourraient être confondus avec des bactéries. Cette étape est
essentielle pour améliorer la précision de l’analyse quantitative qui suivra.

Figure 38 – Image nettoyée des artefacts par morphologie mathématique


1 # Segmentation de l ’ image : label_image contient les d i f f r e n t s labels et n_labels est le
nombre de labels
2 label_image , n_labels = ndimage . label ( open_image )
3 print ( f ’ Il y a { n_labels } groupes de b a c t r i e s ’)
4
5 # Visualisation de l ’ image tiquete
6 plt . imshow ( label_image )
7 plt . title ( " Image s e g m e n t e et tiquete ")
8 plt . colorbar ()
9 plt . show ()

Listing 80 – Segmentation et étiquetage des objets

Explication

La fonction ndimage.label() identifie et étiquette les différentes régions connectées de l’image

(dans ce cas, les différentes bactéries ou colonies). Chaque région reçoit un identifiant unique
(entier), ce qui permet de les distinguer et de les analyser individuellement. La variable n_labels
contient le nombre total de régions identifiées.

Figure 39 – Image segmentée avec chaque bactérie identifiée par une couleur différente

BDCC-S3-2024-2025 60 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 # Mesure de la taille de chaque groupe de label_images ( fait la somme des pixels )
2 sizes = ndimage . sum ( open_image , label_image , range ( n_labels + 1) )
3
4 # Visualisation des r s u l t a t s
5 plt . figure ( figsize =(10 , 6) )
6 plt . scatter ( range (1 , n_labels + 1) , sizes [1:])
7 plt . xlabel ( ’ B a c t r i e ID ’)
8 plt . ylabel ( ’ Taille relative ( pixels ) ’)
9 plt . title ( ’ Distribution des tailles de b a c t r i e s ’)
10 plt . grid ( True , alpha =0.3)
11 plt . tight_layout ()
12 plt . show ()

Listing 81 – Analyse quantitative des objets identifiés

Explication

Finalement, nous mesurons la taille de chaque région identifiée en comptant le nombre de pixels
qu’elle contient. La fonction ndimage.sum() effectue cette opération efficacement en utilisant
l’image étiquetée comme masque. Le graphique résultant montre la distribution des tailles de bac-
téries, ce qui peut être utilisé pour des analyses statistiques ou pour identifier des sous-populations
dans l’échantillon. Notez que nous excluons l’identifiant 0 qui correspond généralement à l’arrière-
plan.

Figure 40 – Distribution des tailles des bactéries identifiées

4.15 Pandas (les Bases) et Analyse du Titanic

Pandas est une bibliothèque Python essentielle pour l’analyse de données, offrant des structures de
données puissantes comme le DataFrame. Dans cette section, nous utiliserons Pandas pour analyser les
données des passagers du Titanic.

1 import numpy as np
2 import matplotlib . pyplot as plt
3 import pandas as pd

Listing 82 – Importation des bibliothèques

Explication

Nous importons ici les bibliothèques fondamentales pour l’analyse de données en Python : NumPy
pour les opérations numériques, Matplotlib pour la visualisation, et Pandas pour la manipulation
et l’analyse des données tabulaires.

BDCC-S3-2024-2025 61 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.15.1 Chargement des données dans un DataFrame Pandas


1 # Les options les plus courantes :
2 # * read_csv
3 # * read_excel
4 data = pd . read_excel ( ’ dataset / titanic3 . xls ’)
5 data . shape
6 data . head (15)

Listing 83 – Chargement des données du Titanic

Explication

Pandas offre plusieurs méthodes pour charger des données depuis divers formats. Ici, nous utilisons
read_excel() pour charger le célèbre jeu de données du Titanic. La méthode shape retourne
les dimensions du DataFrame (nombre de lignes et de colonnes), tandis que head() affiche les
premières lignes (15 dans ce cas) pour un aperçu rapide des données.

Figure 41 – Aperçu des 15 premières lignes du jeu de données du Titanic


1 data . info ()

Listing 84 – Informations sur le DataFrame

Explication

La méthode info() fournit un résumé concis du DataFrame, montrant les types de données
de chaque colonne, le nombre de valeurs non nulles, et l’utilisation de la mémoire. Cette vue
d’ensemble est essentielle pour identifier rapidement les colonnes avec des valeurs manquantes et
comprendre la structure des données.

Figure 42 – Résumé des informations du DataFrame

BDCC-S3-2024-2025 62 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 data . describe ()

Listing 85 – Statistiques descriptives

Explication

La méthode describe() calcule des statistiques descriptives pour chaque colonne numérique :
nombre d’observations, moyenne, écart-type, minimum, maximum, et quartiles. Cette vue d’en-
semble statistique est fondamentale pour comprendre la distribution des variables et détecter
d’éventuelles anomalies ou valeurs aberrantes.

Figure 43 – Statistiques descriptives des variables numériques

4.15.2 Nettoyage des données avec drop(), dropna() et fillna()


1 data = data . drop ([ ’ name ’ , ’ sibsp ’ , ’ parch ’ , ’ ticket ’ , ’ fare ’ , ’ cabin ’ , ’ embarked ’ , ’ boat ’
, ’ body ’ , ’ home . dest ’] , axis =1)
2 data = data . dropna ( axis =0)
3 data . shape
4 data

Listing 86 – Suppression de colonnes et de lignes avec valeurs manquantes

Explication

Le nettoyage des données est une étape cruciale dans tout projet d’analyse. Ici, nous utilisons
drop() pour supprimer les colonnes non pertinentes pour notre analyse, en spécifiant axis=1
pour indiquer que nous supprimons des colonnes. Ensuite, dropna() avec axis=0 élimine toutes
les lignes contenant au moins une valeur manquante. La méthode shape confirme la nouvelle taille
du DataFrame après ces opérations.

Figure 44 – DataFrame après suppression des colonnes non pertinentes et des lignes avec valeurs man-
quantes

BDCC-S3-2024-2025 63 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 data [ ’ age ’ ]. hist ()

Listing 87 – Visualisation de la distribution de l’âge

Explication

La méthode hist() de Pandas (qui utilise Matplotlib en arrière-plan) génère rapidement un

histogramme pour visualiser la distribution d’une variable. Ici, nous observons la distribution des
âges des passagers, ce qui peut révéler des tendances démographiques importantes pour notre
analyse.

Figure 45 – Histogramme de la distribution des âges des passagers

4.15.3 Analyse avec groupby() et value_counts()


1 data . groupby ([ ’ sex ’ ]) . mean ()

Listing 88 – Statistiques par sexe

Explication

La méthode groupby() est l’une des fonctionnalités les plus puissantes de Pandas pour l’analyse
exploratoire. Elle permet de diviser les données en groupes selon une ou plusieurs variables, puis
d’appliquer diverses fonctions d’agrégation comme mean(). Ici, nous calculons la moyenne des
variables numériques pour chaque sexe, ce qui révèle notamment les différences de taux de survie
entre hommes et femmes.

Figure 46 – Moyennes des variables numériques groupées par sexe


1 data . groupby ([ ’ sex ’ , ’ pclass ’ ]) . mean ()

Listing 89 – Statistiques par sexe et classe

BDCC-S3-2024-2025 64 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Nous pouvons également effectuer des groupements plus complexes, comme ici par sexe et classe.
Cette analyse révèle comment le taux de survie varie non seulement selon le sexe, mais aussi selon
la classe sociale, mettant en évidence les intersections de ces facteurs.

Figure 47 – Moyennes des variables numériques groupées par sexe et classe


1 data [ ’ pclass ’ ]. value_counts ()

Listing 90 – Répartition des passagers par classe

Explication

La méthode value_counts() compte les occurrences de chaque valeur unique dans une série.
Ici, nous l’utilisons pour déterminer combien de passagers voyageaient dans chaque classe, ce qui
donne un aperçu de la répartition sociale à bord du Titanic.

Figure 48 – Nombre de passagers par classe


1 data [ data [ ’ age ’] < 18][ ’ pclass ’ ]. value_counts ()

Listing 91 – Répartition des enfants par classe

Explication

En combinant le filtrage conditionnel (data[’age’] < 18) avec value_counts(), nous pouvons
effectuer des analyses plus spécifiques. Ici, nous examinons la répartition par classe des passagers
mineurs, révélant ainsi comment les enfants étaient distribués dans les différentes classes sociales.

BDCC-S3-2024-2025 65 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 49 – Nombre de passagers par classe < 18

4.16 Exercice : Transformation des données


1 def category_ages ( age ) :
2 if age <= 20:
3 return ’ <20 ans ’
4 elif ( age > 20) & ( age <= 30) :
5 return ’ 20 -30 ans ’
6 elif ( age > 30) & ( age <= 40) :
7 return ’ 30 -40 ans ’
8 else :
9 return ’ +40 ans ’
10
11 data [ ’ age ’] = data [ ’ age ’ ]. map ( category_ages )

Listing 92 – Création de catégories d’âge avec map()

Explication

La méthode map() permet d’appliquer une fonction à chaque élément d’une série. Ici, nous défi-
nissons une fonction category_ages() qui convertit l’âge numérique en catégories d’âge. Cette
transformation est utile pour les analyses qui nécessitent des groupes d’âge plutôt que des valeurs
continues.


1 data [ ’ sex ’ ]. astype ( ’ category ’) . cat . codes

Listing 93 – Conversion du sexe en codes catégoriels

Explication

Pour certaines analyses statistiques ou algorithmes de machine learning, il est nécessaire de conver-
tir les variables catégorielles en codes numériques. Ici, nous convertissons d’abord la colonne
’sex’ en type catégoriel avec astype(’category’), puis accédons aux codes numériques avec
cat.codes. Cette méthode attribue automatiquement un entier unique à chaque catégorie.

Figure 50 – Conversion des catégories de sexe en codes numériques

BDCC-S3-2024-2025 66 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.17 Pandas et séries temporelles

Les séries temporelles sont des séquences de données indexées chronologiquement, et Pandas offre des
outils puissants pour leur manipulation et analyse.

4.17.1 Travailler avec des séries temporelles


1 import numpy as np
2 import matplotlib . pyplot as plt
3 import pandas as pd
4
5 # Chargement des d o n n e s Bitcoin avec index temporel
6 bitcoin = pd . read_csv ( ’BTC - EUR . csv ’ , index_col = ’ Date ’ , parse_dates = True )
7 bitcoin . head ()

Listing 94 – Importation et préparation des données

Explication

Lors du chargement de données temporelles avec Pandas, deux paramètres sont particulièrement
importants : index_col=’Date’ spécifie que la colonne "Date" doit être utilisée comme index, et
parse_dates=True indique à Pandas de convertir ces valeurs en objets datetime. Cette configura-
tion nous permet d’exploiter pleinement les fonctionnalités de Pandas pour les séries temporelles.

Figure 51 – Aperçu des données Bitcoin avec index temporel


1 bitcoin [ ’ Close ’ ]. plot ( figsize =(9 , 6) )
2 plt . show ()

Listing 95 – Visualisation des données temporelles

Explication

La méthode plot() de Pandas crée automatiquement un graphique chronologique lorsque l’index

est de type datetime. Cela nous donne un aperçu rapide de l’évolution du prix de clôture du
Bitcoin au fil du temps, révélant les tendances et la volatilité du marché.

BDCC-S3-2024-2025 67 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 52 – Évolution du prix de clôture du Bitcoin


1 bitcoin . index

Listing 96 – Exploration de l’index temporel

Explication

L’examen de l’index d’un DataFrame temporel nous permet de comprendre sa structure, sa fré-
quence et sa plage de dates. Nous pouvons voir que l’index est bien un DatetimeIndex, ce qui
confirme que Pandas a correctement interprété nos dates.

Figure 53 – Structure de l’index temporel du DataFrame


1 bitcoin . loc [ ’ 2017 ’: ’ 2019 ’ , ’ Close ’ ]. plot ()

Listing 97 – Sélection par plage de dates

Explication

L’indexation temporelle permet des sélections intuitives de périodes avec la notation slice
(’start’:’end’). Ici, nous extrayons et visualisons les prix de clôture du Bitcoin de 2017 à
2019, ce qui nous permet d’analyser l’évolution du marché pendant cette période spécifique.

BDCC-S3-2024-2025 68 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 54 – Prix de clôture du Bitcoin de 2017 à 2019

4.17.2 Utilisation de resample()


1 bitcoin . loc [ ’ 2019 ’ , ’ Close ’ ]. resample ( ’M ’) . plot ()
2 plt . show ()

Listing 98 – Agrégation mensuelle des données

Explication

La méthode resample() est essentielle pour l’analyse des séries temporelles, car elle permet de
modifier la fréquence des données. Ici, ’M’ indique un rééchantillonnage mensuel, où chaque point
représente la dernière valeur du mois. Cette technique est utile pour réduire le bruit et observer
les tendances à plus long terme.

Figure 55 – Prix de clôture du Bitcoin en 2019, échantillonné mensuellement


1 bitcoin . loc [ ’ 2019 ’ , ’ Close ’ ]. resample ( ’2 W ’) . mean () . plot ()
2 plt . show ()

Listing 99 – Rééchantillonnage bi-hebdomadaire avec moyenne

BDCC-S3-2024-2025 69 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Nous pouvons spécifier différentes fréquences de rééchantillonnage et méthodes d’agrégation. Ici,

’2W’ indique une période de deux semaines, et mean() calcule la moyenne des valeurs dans chaque
période. Ce niveau intermédiaire d’agrégation peut offrir un équilibre entre le détail et la tendance
générale.

Figure 56 – Moyenne bi-hebdomadaire des prix du Bitcoin en 2019


1 plt . figure ( figsize =(12 , 8) )
2 bitcoin . loc [ ’ 2019 ’ , ’ Close ’ ]. plot ()
3 bitcoin . loc [ ’ 2019 ’ , ’ Close ’ ]. resample ( ’M ’) . mean () . plot ( label = ’ moyenne par mois ’ , lw =3 , ls
= ’: ’ , alpha =0.8)
4 bitcoin . loc [ ’ 2019 ’ , ’ Close ’ ]. resample ( ’W ’) . mean () . plot ( label = ’ moyenne par semaine ’ , lw =2 ,
ls = ’ -- ’ , alpha =0.8)
5 plt . legend ()
6 plt . show ()

Listing 100 – Comparaison des différentes fréquences d’échantillonnage

Explication

La comparaison de différentes fréquences d’échantillonnage sur un même graphique permet d’ob-

server comment le niveau de granularité affecte notre perception des données. Les moyennes men-
suelles offrent une vue plus lissée des tendances générales, tandis que les moyennes hebdomadaires
capturent plus de détails tout en réduisant une partie du bruit quotidien.

Figure 57 – Comparaison des données journalières, hebdomadaires et mensuelles du Bitcoin

BDCC-S3-2024-2025 70 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

4.17.3 Utilisation de agg() pour des statistiques multiples


1 m = bitcoin [ ’ Close ’ ]. resample ( ’W ’) . agg ([ ’ mean ’ , ’ std ’ , ’ min ’ , ’ max ’ ])
2 plt . figure ( figsize =(12 , 8) )
3 m [ ’ mean ’ ][ ’ 2019 ’ ]. plot ( label = ’ moyenne par semaine ’)
4 plt . fill_between ( m . index , m [ ’ max ’] , m [ ’ min ’] , alpha =0.2 , label = ’min - max par semaine ’)
5 plt . legend ()
6 plt . show ()

Listing 101 – Calcul de statistiques multiples par semaine

Explication

La méthode agg() permet d’appliquer plusieurs fonctions d’agrégation simultanément lors du

rééchantillonnage. Ici, nous calculons la moyenne, l’écart-type, le minimum et le maximum des
prix hebdomadaires. La visualisation utilise fill_between() pour représenter la plage de variation
des prix (entre le minimum et le maximum) chaque semaine, ce qui donne une indication de la
volatilité.

Figure 58 – Moyenne hebdomadaire et plage min-max des prix du Bitcoin en 2019


1 bitcoin . loc [ ’ 2019 ’ , ’ Close ’ ]. resample ( ’W ’) . agg ([ ’ mean ’ , ’ std ’ , ’ min ’ , ’ max ’ ]) . plot ()

Listing 102 – Visualisation des statistiques multiples

Explication

Pandas génère automatiquement un graphique avec des sous-tracés pour chaque statistique calcu-
lée par agg(). Cette visualisation permet de comparer facilement différentes mesures statistiques
sur la même période, révélant par exemple comment l’écart-type (volatilité) évolue par rapport à
la moyenne des prix.

BDCC-S3-2024-2025 71 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 59 – Statistiques hebdomadaires des prix du Bitcoin en 2019

4.17.4 Moyennes mobiles et moyennes mobiles exponentielles (EWM)


1 plt . figure ( figsize =(12 , 8) )
2 bitcoin . loc [ ’ 2019 -09 ’ , ’ Close ’ ]. plot ()
3 bitcoin . loc [ ’ 2019 -09 ’ , ’ Close ’ ]. rolling ( window =7) . mean () . plot ( label = ’ non centre ’ , lw =3 ,
ls = ’: ’ , alpha =0.8)
4 bitcoin . loc [ ’ 2019 -09 ’ , ’ Close ’ ]. rolling ( window =7 , center = True ) . mean () . plot ( label = ’ centre ’
, lw =3 , ls = ’: ’ , alpha =0.8)
5 bitcoin . loc [ ’ 2019 -09 ’ , ’ Close ’ ]. ewm ( alpha =0.6) . mean () . plot ( label = ’ ewm ’ , lw =3 , ls = ’: ’ ,
alpha =0.8)
6 plt . legend ()
7 plt . show ()

Listing 103 – Comparaison des différentes moyennes mobiles

Explication

Les moyennes mobiles sont des outils essentiels pour lisser les fluctuations à court terme et révéler
les tendances. La méthode rolling() calcule une moyenne mobile simple, avec options comme
center=True qui aligne la fenêtre au centre de la période plutôt qu’à la fin. La méthode ewm()
(Exponentially Weighted Moving average) donne plus de poids aux observations récentes, avec
alpha contrôlant ce biais : une valeur élevée donne plus d’importance aux données récentes.

Figure 60 – Comparaison des moyennes mobiles classiques et exponentielles

BDCC-S3-2024-2025 72 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 plt . figure ( figsize =(12 , 8) )
2 bitcoin . loc [ ’ 2019 -09 ’ , ’ Close ’ ]. plot ()
3 for i in np . arange (0.2 , 1 , 0.2) :
4 bitcoin . loc [ ’ 2019 -09 ’ , ’ Close ’ ]. ewm ( alpha = i ) . mean () . plot ( label = f ’ ewm { i } ’ , ls = ’ -- ’ ,
alpha =0.8)
5 plt . legend ()
6 plt . show ()

Listing 104 – Effet du paramètre alpha sur les moyennes mobiles exponentielles

Explication

Cette visualisation explore l’impact du paramètre alpha sur les moyennes mobiles exponentielles.
Des valeurs d’alpha plus élevées produisent des moyennes qui réagissent plus rapidement aux
changements récents, tandis que des valeurs plus faibles donnent un lissage plus important. Le
choix optimal d’alpha dépend de l’application spécifique et du compromis souhaité entre réactivité
et stabilité.

Figure 61 – Effet de différentes valeurs d’alpha sur les moyennes mobiles exponentielles

4.17.5 Comparaison de deux séries temporelles


1 ethereum = pd . read_csv ( ’ETH - EUR . csv ’ , index_col = ’ Date ’ , parse_dates = True )
2 btc_eth = pd . merge ( bitcoin , ethereum , on = ’ Date ’ , how = ’ inner ’ , suffixes =( ’ _btc ’ , ’ _eth ’) )
3 btc_eth [[ ’ Close_btc ’ , ’ Close_eth ’ ]][ ’ 2019 -09 ’ ]. plot ( subplots = True , figsize =(12 , 8) )

Listing 105 – Fusion et comparaison de séries temporelles

BDCC-S3-2024-2025 73 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Pour comparer deux séries temporelles, nous commençons par charger les données d’Ethereum
de manière similaire à celles du Bitcoin. La fonction pd.merge() combine les deux DataFrames
en utilisant les dates comme clé de jointure, avec how=’inner’ pour ne conserver que les dates
présentes dans les deux jeux de données. L’option subplots=True crée un graphique par série,
facilitant la comparaison visuelle des tendances entre Bitcoin et Ethereum.

Figure 62 – Comparaison des prix de clôture du Bitcoin et de l’Ethereum en septembre 2019

4.18 Exercice et Solution : Stratégie de trading simple


1 data = bitcoin . copy ()
2 data [ ’ Buy ’] = np . zeros ( len ( data ) )
3 data [ ’ Sell ’] = np . zeros ( len ( data ) )
4
5 # Calcul des maximum et minimum glissants sur 28 jours
6 data [ ’ RollingMax ’] = data [ ’ Close ’ ]. shift (1) . rolling ( window =28) . max ()
7 data [ ’ RollingMin ’] = data [ ’ Close ’ ]. shift (1) . rolling ( window =28) . min ()
8
9 # G n r a t i o n des signaux d ’ achat et de vente
10 data . loc [ data [ ’ RollingMax ’] < data [ ’ Close ’] , ’ Buy ’] = 1
11 data . loc [ data [ ’ RollingMin ’] > data [ ’ Close ’] , ’ Sell ’] = -1
12
13 # Visualisation des r s u l t a t s
14 start = ’ 2019 ’
15 end = ’ 2019 ’
16 fig , ax = plt . subplots (2 , figsize =(12 , 8) , sharex = True )
17 ax [0]. plot ( data [ ’ Close ’ ][ start : end ])
18 ax [0]. plot ( data [ ’ RollingMin ’ ][ start : end ])
19 ax [0]. plot ( data [ ’ RollingMax ’ ][ start : end ])
20 ax [0]. legend ([ ’ close ’ , ’ min ’ , ’ max ’ ])
21 ax [1]. plot ( data [ ’ Buy ’ ][ start : end ] , c = ’g ’)
22 ax [1]. plot ( data [ ’ Sell ’ ][ start : end ] , c = ’r ’)
23 ax [1]. legend ([ ’ buy ’ , ’ sell ’ ])

Listing 106 – Implémentation d’une stratégie de trading basée sur les extremums glissants

BDCC-S3-2024-2025 74 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Cet exercice implémente une stratégie de trading simple basée sur des seuils adaptatifs. Nous
calculons le maximum et le minimum glissants sur une fenêtre de 28 jours, en utilisant shift(1)
pour ne considérer que les données disponibles à chaque point de décision (évitant ainsi le biais
d’anticipation). Les signaux d’achat sont générés lorsque le prix actuel dépasse le maximum récent
(potentielle tendance haussière), et les signaux de vente lorsque le prix tombe sous le minimum
récent (potentielle tendance baissière). La visualisation en deux parties permet d’observer simul-
tanément l’évolution des prix et les signaux générés par la stratégie. Ce type d’analyse est un
exemple simple d’application des séries temporelles à la finance quantitative.

Figure 63 – Stratégie de trading basée sur les extremums glissants appliquée au Bitcoin en 2019

4.19 Visualisation de Données avec Seaborn

Les bibliothèques Matplotlib et Pandas offrent d’excellentes fonctionnalités de visualisation, mais
Seaborn les complète avec des graphiques statistiques élégants et des palettes de couleurs soignées.

4.19.1 Prise en main de Seaborn


1 import numpy as np
2 import matplotlib . pyplot as plt
3 import pandas as pd
4 import seaborn as sns
5
6 # Chargement du jeu de d o n n e s Iris
7 iris = sns . load_dataset ( ’ iris ’)
8 iris . head ()

Listing 107 – Importation et préparation des données

Explication

Seaborn intègre plusieurs jeux de données prêts à l’emploi, comme le célèbre jeu de données Iris
utilisé ici. La méthode load_dataset() simplifie l’accès à ces données d’exemple, idéales pour
explorer les fonctionnalités de visualisation de la bibliothèque.

BDCC-S3-2024-2025 75 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Figure 64 – Aperçu du jeu de données Iris

4.19.2 Pairplot() : La vue d’ensemble


1 sns . pairplot ( iris , hue = ’ species ’)

Listing 108 – Visualisation des relations entre variables

Explication

La fonction pairplot() est un outil puissant qui crée une matrice de graphiques montrant les
relations entre toutes les paires de variables numériques. Le paramètre hue colore les points selon
une variable catégorielle, permettant de visualiser rapidement comment les différentes espèces
d’iris se distinguent selon leurs caractéristiques. Cette visualisation est particulièrement utile pour
explorer les corrélations multivariées et identifier des motifs de séparation entre catégories.

Figure 65 – Matrice de nuages de points des caractéristiques d’iris par espèce

4.19.3 Visualiser des catégories


1 titanic = sns . load_dataset ( ’ titanic ’)
2 titanic . drop ([ ’ alone ’ , ’ alive ’ , ’ who ’ , ’ adult_male ’ , ’ embark_town ’ , ’ class ’] , axis =1 ,
inplace = True )
3 titanic . dropna ( axis =0 , inplace = True )
4 titanic . head ()

Listing 109 – Préparation des données Titanic

BDCC-S3-2024-2025 76 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Le jeu de données Titanic est couramment utilisé pour l’analyse de données catégorielles. Nous
préparons les données en supprimant certaines colonnes redondantes et en éliminant les lignes
contenant des valeurs manquantes avec dropna(). Cette étape de nettoyage est essentielle pour
garantir des visualisations fiables et interprétables.

Figure 66 – Aperçu du jeu de données Titanic nettoyé


1 sns . catplot ( x = ’ survived ’ , y = ’ age ’ , data = titanic , hue = ’ sex ’)

Listing 110 – Visualisation catégorielle avec catplot

Explication

La fonction catplot() est spécialisée dans la visualisation des relations entre variables catégorielles
et numériques. Ici, nous examinons la distribution des âges selon le statut de survie et le genre.
Ce type de graphique permet d’identifier rapidement des tendances démographiques, comme la
priorité donnée aux femmes et aux enfants lors de l’évacuation du Titanic.

Figure 67 – Distribution des âges selon le statut de survie et le genre


1 plt . figure ( figsize =(32 , 8) )
2 sns . boxplot ( x = ’ age ’ , y = ’ fare ’ , data = titanic , hue = ’ sex ’)

Listing 111 – Visualisation avec boîtes à moustaches

BDCC-S3-2024-2025 77 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES

Explication

Les boîtes à moustaches (boxplots) sont idéales pour comparer des distributions numériques. Ici,
nous analysons la relation entre l’âge et le prix du billet, avec une stratification par genre. Ce
graphique révèle non seulement les tendances centrales, mais aussi la dispersion et les valeurs
aberrantes dans chaque groupe, offrant une vision complète de la distribution des tarifs selon l’âge
et le genre des passagers.

Figure 68 – Boîtes à moustaches des tarifs selon l’âge et le genre

4.19.4 Visualisation de Distributions


1 sns . distplot ( titanic [ ’ fare ’ ])

Listing 112 – Histogramme avec courbe de densité

Explication

La fonction distplot() combine un histogramme avec une estimation de densité par noyau
(KDE), offrant une représentation complète de la distribution d’une variable numérique. Cette
visualisation de la distribution des tarifs du Titanic révèle une forte asymétrie positive, avec de
nombreux passagers ayant payé des tarifs bas et quelques-uns des tarifs très élevés.

Figure 69 – Distribution des tarifs des passagers du Titanic

BDCC-S3-2024-2025 78 Mohamed Ouazze

 4 BIBLIOTHÈQUES ESSENTIELLES


1 sns . jointplot ( ’ age ’ , ’ fare ’ , data = titanic , kind = ’ hex ’)

Listing 113 – Graphique de distribution conjointe

Explication

La fonction jointplot() crée une visualisation qui combine un nuage de points central avec des
histogrammes marginaux, permettant d’examiner simultanément la distribution conjointe et les
distributions marginales de deux variables. L’option kind=’hex’ génère un graphique hexbin,
particulièrement adapté pour visualiser des densités dans des jeux de données volumineux en
évitant la surcharge visuelle. Cette visualisation révèle la relation complexe entre l’âge et le tarif
payé par les passagers du Titanic.

Figure 70 – Distribution conjointe hexbin de l’âge et du tarif


1 sns . heatmap ( titanic . corr () )

Listing 114 – Matrice de corrélation avec heatmap

Explication

La fonction heatmap() est idéale pour visualiser des matrices de données, en particulier des ma-
trices de corrélation. Les couleurs représentent l’intensité des corrélations entre paires de variables,
facilitant l’identification rapide des relations fortes ou faibles. Cette carte thermique des corréla-
tions dans le jeu de données Titanic permet d’identifier quelles variables sont les plus liées au taux
de survie et entre elles.

Figure 71 – Matrice de corrélation des variables du jeu de données Titanic

BDCC-S3-2024-2025 79 Mohamed Ouazze

 5 MACHINE LEARNING

5 Machine Learning
Le Machine Learning (apprentissage automatique) consiste à développer un modèle mathématique à
partir de données expérimentales. Il existe plusieurs types d’apprentissage :
— Apprentissage supervisé
— Apprentissage non supervisé
— Apprentissage par renforcement

5.1 Apprentissage Supervisé avec Sklearn

La machine reçoit des données caractérisées par des variables X (features) et annotées par des
variables y (labels). En fournissant beaucoup de données à la machine, on constitue un dataset. On
spécifie le type de modèle que la machine doit apprendre (linéaire, polynomial, arbre de décision,
réseau de neurones. . .). En précisant les hyperparamètres du modèle (combien de branches dans
un arbre, combien de neurones. . .). La machine utilise un algorithme d’optimisation pour trouver
les paramètres fournissant les meilleures performances sur le dataset (phase d’entraînement).

5.1.1 Régression

1 import numpy as np
2 import matplotlib . pyplot as plt
3 import seaborn as sns
4
5 np . random . seed (0)
6 m = 100 # c r a t i o n de 100 chantillons
7 X = np . linspace (0 , 10 , m ) . reshape (m ,1)
8 y = X + np . random . randn (m , 1)
9 plt . scatter (X , y )

Listing 115 – Création et visualisation des données

Explication

Pour illustrer la régression linéaire, nous générons un jeu de données synthétique avec une relation
linéaire entre X et y, à laquelle nous ajoutons un bruit gaussien. La visualisation sous forme
de nuage de points permet d’observer cette relation linéaire bruitée, typique des problèmes de
régression réels.

Figure 72 – Jeu de données synthétique pour la régression linéaire

BDCC-S3-2024-2025 80 Mohamed Ouazze

 5 MACHINE LEARNING


1 from sklearn . linear_model import L i n e a r R e g r e s s i o n
2
3 model = L i n e a r R e g r e s s i o n ()
4 model . fit (X , y ) # e n t r a n e m e n t du m o d l e
5 model . score (X , y ) # valuation avec le coefficient de c o r r l a t i o n
6 model . predict ( X )
7
8 plt . scatter (X , y )
9 plt . plot (X , model . predict ( X ) , c = ’ red ’)

Listing 116 – Entraînement d’un modèle de régression linéaire

Explication

Nous utilisons la classe LinearRegression de scikit-learn pour entraîner un modèle de régression

linéaire sur nos données. La méthode fit() optimise les paramètres du modèle (pente et ordonnée
à l’origine) pour minimiser l’erreur quadratique. La méthode score() retourne le coefficient de
détermination R², qui mesure la qualité de l’ajustement. Enfin, nous visualisons les prédictions
du modèle superposées aux données originales.

Figure 73 – Régression linéaire ajustée aux données

5.1.2 Classification

1 titanic = sns . load_dataset ( ’ titanic ’)
2 titanic = titanic [[ ’ survived ’ , ’ pclass ’ , ’ sex ’ , ’ age ’ ]]
3 titanic . dropna ( axis =0 , inplace = True )
4 titanic [ ’ sex ’ ]. replace ([ ’ male ’ , ’ female ’] , [0 , 1] , inplace = True )
5 titanic . head ()

Listing 117 – Préparation des données pour la classification

Explication

Pour notre exemple de classification, nous utilisons le célèbre jeu de données du Titanic. Nous
sélectionnons les variables les plus pertinentes pour prédire la survie des passagers : la classe
(pclass), le sexe (sex) et l’âge (age). Nous nettoyons les données en supprimant les lignes avec
des valeurs manquantes et en encodant la variable catégorielle sex en valeurs numériques.

BDCC-S3-2024-2025 81 Mohamed Ouazze

 5 MACHINE LEARNING

Figure 74 – Jeu de données Titanic préparé pour la classification


1 from sklearn . neighbors import K N e i g h b o r s C l a s s i f i e r
2
3 model = K N e i g h b o r s C l a s s i f i e r ()
4 y = titanic [ ’ survived ’]
5 X = titanic . drop ( ’ survived ’ , axis =1)
6
7 model . fit (X , y ) # e n t r a n e m e n t du m o d l e
8 model . score (X , y ) # valuation

Listing 118 – Entraînement d’un modèle de classification

Explication

Pour la classification, nous utilisons l’algorithme des k plus proches voisins (KNN) implémenté
dans la classe KNeighborsClassifier. Nous séparons les données en features X et labels y, puis
entraînons le modèle. La méthode score() calcule la précision du modèle sur les données d’entraî-
nement. Notez que dans un contexte réel, il serait préférable de diviser les données en ensembles
d’entraînement et de test pour évaluer correctement les performances du modèle.

5.1.3 Prédiction de survie


1 def survie ( model , pclass =3 , sex =0 , age =26) :
2 x = np . array ([ pclass , sex , age ]) . reshape (1 , 3)
3 print ( model . predict ( x ) )
4 print ( model . predict_proba ( x ) )
5
6 survie ( model )

Listing 119 – Fonction de prédiction de survie

Explication

Nous créons une fonction utilitaire survie() qui prédit la probabilité de survie d’un passager en
fonction de sa classe, son sexe et son âge. La fonction utilise predict() pour obtenir la prédiction
binaire (0 ou 1) et predict_proba() pour obtenir les probabilités associées à chaque classe. Par
défaut, la fonction prédit la survie d’un homme de 26 ans voyageant en 3ème classe.

Exercice

Écrire un code qui permet de trouver la meilleure valeur du paramètre n_neighbors pour le modèle
KNeighborsClassifier. Dans sklearn, il est possible de faire cela avec la classe GridSearchCV. Mais
il peut également être utile de savoir écrire soi-même ce genre de code de recherche.

BDCC-S3-2024-2025 82 Mohamed Ouazze

 5 MACHINE LEARNING

Solution

1 # SOLUTION
2 score = []
3 best_k = 1
4 best_score = 0
5 for k in range ( best_k , 30) :
6 model = K N e i g h b o r s C l a s s i f i e r ( n_neighbors = k )
7 model . fit (X , y )
8 score . append ( model . score (X , y ) )
9
10 if best_score < model . score (X , y ) :
11 best_k = k
12 best_score = model . score (X , y )
13 print ( best_k )
14 plt . plot ( score )

Listing 120 – Recherche du meilleur nombre de voisins

Explication

Cette solution implémente une recherche manuelle du meilleur hyperparamètre n_neighbors pour
l’algorithme KNN. Pour chaque valeur de k de 1 à 30, nous entraînons un nouveau modèle et en-
registrons sa précision. Nous gardons trace du k donnant la meilleure précision. Le graphique
montre l’évolution de la précision en fonction du nombre de voisins, ce qui aide à comprendre le
compromis entre sous-ajustement et sur-ajustement. Notons que cette approche utilise les mêmes
données pour l’entraînement et l’évaluation, ce qui peut conduire à du sur-ajustement ; une vali-
dation croisée serait plus appropriée dans un contexte réel.

Figure 75 – Évolution de la précision en fonction du nombre de voisins

5.2 Sklearn : Sélection de Modèle

La sélection et l’évaluation correctes des modèles sont des étapes essentielles pour garantir la généra-
lisation des performances aux données non vues pendant l’entraînement.

1 import numpy as np
2 import matplotlib . pyplot as plt
3 from sklearn . datasets import load_iris
4
5 iris = load_iris ()
6 X = iris . data
7 y = iris . target
8
9 plt . scatter ( X [: , 0] , X [: , 1] , c =y , alpha =0.8)
10 plt . xlabel ( " Longueur du s p a l e ( cm ) " )
11 plt . ylabel ( " Largeur du s p a l e ( cm ) " )
12 plt . title ( " Distribution des Iris " )
13 plt . show ()

Listing 121 – Chargement et visualisation du jeu de données Iris

BDCC-S3-2024-2025 83 Mohamed Ouazze

 5 MACHINE LEARNING

Explication

Nous utilisons ici le célèbre jeu de données Iris, intégré à scikit-learn. La fonction load_iris()
charge les données sous forme de tableau :
— iris.data contient les caractéristiques (features)
— iris.target contient les classes (étiquettes)
La visualisation permet d’observer la séparation naturelle des classes selon deux caractéristiques :
la longueur et la largeur du sépale.

Figure 76 – Distribution des trois espèces d’iris selon les caractéristiques des sépales

5.3 Train Test Split

En machine learning, il ne faut jamais évaluer la performance d’un modèle sur les données d’entraî-
nement !

1 # En pratique , on utiliserait :
2 from sklearn . m od el _ se le c ti o n import t r a i n _ t e s t _ s p l i t
3
4 X_train , X_test , y_train , y_test = t r a i n _ t e s t _ s p l i t (X , y , test_size =0.2 , random_state =42)
5
6 model . fit ( X_train , y_train ) # E n t r a n e m e n t sur l ’ ensemble d ’ e n t r a n e m e n t
7 performance = model . score ( X_test , y_test ) # valuation sur l ’ ensemble de test

Listing 122 – Séparation des données en ensembles d’entraînement et de test

Explication

La séparation des données est fondamentale :

— L’ensemble d’entraînement (environ 70% à 80% des données) sert à apprendre.
— L’ensemble de test (les 20% à 30% restants) est réservé pour évaluer les performances
finales.
Cela garantit que l’évaluation reflète bien la capacité du modèle à généraliser à de nouvelles
données.

BDCC-S3-2024-2025 84 Mohamed Ouazze

 5 MACHINE LEARNING

Train-test split

Train set (80%) Test set (20%)

X_train, y_train X_test, y_test

model.fit(X_train, model.score(X_test,
y_train) y_test)

Figure 77 – Processus de séparation des données en ensembles d’entraînement et de test


1 # En pratique :
2 plt . figure ( figsize =(12 , 4) )
3 plt . subplot (121)
4 plt . scatter ( X_train [: , 0] , X_train [: , 1] , c = y_train , alpha =0.8)
5 plt . title ( ’ Train set ’)
6 plt . subplot (122)
7 plt . scatter ( X_test [: , 0] , X_test [: , 1] , c = y_test , alpha =0.8)
8 plt . title ( ’ Test set ’)

Listing 123 – plot partie train et test

Figure 78 – Dévision de dataset train test split

5.4 Validation Set Approach

Pour une évaluation encore plus rigoureuse, on utilise un ensemble de validation.

1 # En pratique :
2 X_train_val , X_test , y_train_val , y_test = t r a i n _ t e s t _ s p l i t (X , y , test_size =0.2 ,
random_state =42)
3 X_train , X_val , y_train , y_val = t r a i n _ t e s t _ s p l i t ( X_train_val , y_train_val , test_size
=0.25 , random_state =42)
4
5 model . fit ( X_train , y_train ) # E n t r a n e m e n t sur train
6 v a l i d a t i o n _ s c o r e = model . score ( X_val , y_val ) # Validation pour s l e c t i o n de m o d l e
7 final_score = model . score ( X_test , y_test ) # valuation finale sur test

Listing 124 – Utilisation d’un ensemble de validation

BDCC-S3-2024-2025 85 Mohamed Ouazze

 5 MACHINE LEARNING

Explication

Avec un ensemble de validation :

— On divise d’abord les données en 80% (train + validation) et 20% (test).
— Puis 80% du premier ensemble pour l’entraînement et 20% pour la validation.
Cela permet d’ajuster les hyperparamètres sans toucher aux données finales de test.

Train-validation split (sur

partie entraînement)

Train set (75%) Validation set (25%)

X_train, y_train X_val, y_val

model.fit(X_train, y_train) model.score(X_val, y_val)

Figure 79 – Processus de validation pour la sélection de modèle

5.5 Validation Set et Cross Validation

La cross-validation est une technique qui permet d’entraîner le modèle de façon découpée pour obtenir
une évaluation plus robuste.

Figure 80 – cross-validation pour différentes valeurs


1 from sklearn . m od el _ se le c ti o n import c ro ss _ va l_ s co re
2 model = K N e i g h b o r s C l a s s i f i e r ()
3 c ro ss _ va l_ s co r e ( model , X_train , y_train , cv =5 , scoring = ’ accuracy ’)
4
5 val_score = []
6 for k in range (1 , 50) :
7 score = c ro s s_ va l _s c or e ( K N e i g h b o r s C l a s s i f i e r ( k ) , X_train , y_train , cv =5) . mean ()
8 val_score . append ( score )
9 plt . plot ( val_score )

Listing 125 – Cross-validation avec scikit-learn

BDCC-S3-2024-2025 86 Mohamed Ouazze

 5 MACHINE LEARNING

Explication

La cross-validation divise les données d’entraînement en plusieurs sous-ensembles (folds). Le mo-

dèle est entraîné sur tous les sous-ensembles sauf un, qui sert de validation. L’opération est répétée
pour chaque sous-ensemble, et les résultats sont moyennés pour obtenir une évaluation plus fiable.
Avec cv=5, les données sont divisées en 5 parties égales, créant un processus de validation croisée
à 5 plis (5-fold cross-validation).

Figure 81 – Résultats de cross-validation pour différentes valeurs de k

5.6 Validation Curve

Les courbes de validation permettent de visualiser l’impact d’un hyperparamètre sur les performances
du modèle.

1 from sklearn . m od el _ se le c ti o n import va l i d a t i o n _ c u r v e
2 model = K N e i g h b o r s C l a s s i f i e r ()
3 k = np . arange (1 , 50)
4 train_score , val_score = v a l i d a t i o n _ c u r v e ( model , X_train , y_train ,
5 ’ n_neighbors ’ , k , cv =5)
6 plt . plot (k , val_score . mean ( axis =1) , label = ’ validation ’)
7 plt . plot (k , train_score . mean ( axis =1) , label = ’ train ’)
8 plt . ylabel ( ’ score ’)
9 plt . xlabel ( ’ n_neighbors ’)
10 plt . legend ()

Listing 126 – Génération de courbes de validation

Explication

La fonction validation_curve permet d’évaluer l’impact d’un hyperparamètre spécifique :

— n_neighbors : nom de l’hyperparamètre à régler
— k : plage de valeurs à tester pour cet hyperparamètre
— cv : nombre de découpages pour la validation croisée
Les courbes montrent comment les scores d’entraînement et de validation évoluent en fonction de
la valeur de k.

BDCC-S3-2024-2025 87 Mohamed Ouazze

 5 MACHINE LEARNING

Figure 82 – Courbes de validation montrant les performances sur les ensembles d’entraînement et de
validation

5.7 GridSearchCV
GridSearchCV construit une grille de modèles avec toutes les combinaisons d’hyperparamètres pos-
sibles définies dans param_grid.

Figure 83 – grid search


1 from sklearn . m od el _ se le c ti o n import GridSearchCV
2 param_grid = { ’ n_neighbors ’: np . arange (1 , 20) ,
3 ’ metric ’: [ ’ euclidean ’ , ’ manhattan ’ ]}
4 grid = GridSearchCV ( K N e i g h b o r s C l a s s i f i e r () , param_grid , cv =5)
5 grid . fit ( X_train , y_train )
6
7 print ( grid . best_score_ )
8 print ( grid . best_params_ )
9
10 model = grid . b e st _ es ti m at or _
11 model . score ( X_test , y_test )

Listing 127 – Recherche par grille d’hyperparamètres

Explication

GridSearchCV automatise la recherche des meilleurs hyperparamètres :

— param_grid définit l’espace de recherche (ici 19 valeurs pour k × 2 métriques = 38 combi-
naisons)
— Chaque combinaison est évaluée avec une validation croisée à 5 plis
— best_params_ renvoie la combinaison optimale d’hyperparamètres
— best_estimator_ fournit le modèle déjà configuré avec ces paramètres

BDCC-S3-2024-2025 88 Mohamed Ouazze

 5 MACHINE LEARNING

Figure 84 – Visualisation des résultats de la recherche par grille

5.8 Confusion Matrix

La matrice de confusion est un outil utilisé en apprentissage automatique pour évaluer les performances
d’un modèle de classification. Elle compare les prédictions faites par le modèle aux valeurs réelles afin
d’identifier les cas correctement et incorrectement classifiés.

Figure 85 – Matrice Conf


1 from sklearn . metrics import c o n f u s i o n _ m a t r i x
2 c o n f u s i o n _ m a t r i x ( y_test , model . predict ( X_test ) )

Listing 128 – Calcul de la matrice de confusion

Explication

La matrice de confusion présente :

— Sur la diagonale : les prédictions correctes (vrais positifs et vrais négatifs)
— Hors diagonale : les erreurs de classification (faux positifs et faux négatifs)
C’est un outil essentiel pour comprendre les types d’erreurs commises par le modèle.

Figure 86 – Exemple de matrice de confusion pour le modèle optimisé

BDCC-S3-2024-2025 89 Mohamed Ouazze

 5 MACHINE LEARNING

5.9 Learning Curve

Les courbes d’apprentissage permettent de visualiser l’évolution des performances du modèle en fonc-
tion de la taille des données d’entraînement.

1 from sklearn . m od el _ se le c ti o n import l earnin g_curv e
2 N , train_score , val_score = lea rning_ curve ( model , X_train , y_train ,
3 train_sizes = np . linspace (0.1 , 1 , 10) , cv =5)
4 print ( N )
5 plt . plot (N , train_score . mean ( axis =1) , label = ’ train ’)
6 plt . plot (N , val_score . mean ( axis =1) , label = ’ validation ’)
7 plt . xlabel ( ’ train_sizes ’)
8 plt . legend ()

Listing 129 – Génération de courbes d’apprentissage

Explication

La fonction learning_curve évalue les performances du modèle avec des sous-ensembles croissants
des données d’entraînement :
— train_sizes spécifie les proportions des données à utiliser (de 10% à 100%)
— Les courbes permettent de détecter le sur-apprentissage ou sous-apprentissage
— Un écart important entre les scores d’entraînement et de validation indique un sur-
apprentissage
— Des scores faibles sur les deux ensembles suggèrent un sous-apprentissage

Figure 87 – Courbes d’apprentissage montrant l’évolution des performances en fonction de la taille des
données

5.10 Partie 2 : Cross-validation

La cross-validation est une technique robuste pour évaluer les performances d’un modèle sur différents
sous-ensembles de données.

1 # Cross - validation avec K - Fold
2 c ro ss _ va l_ s co r e ( estimateur , X_train , y_train , cv = KFold (5 , random_state =0) , scoring = ’
accuracy ’)

Listing 130 – Différentes méthodes de cross-validation

Explication

Divise les données en 5 sous-ensembles (ou folds). À chaque itération, un fold est utilisé pour le
test, et les autres pour l’entraînement.

BDCC-S3-2024-2025 90 Mohamed Ouazze

 5 MACHINE LEARNING

Figure 88 – Illustration de la méthode K-Fold avec 5 folds


1 # Cross - validation avec Leave - One - Out
2 c ro ss _ va l_ s co r e ( estimateur , X_train , y_train , cv = LeaveOneOut () )

Listing 131 – Cross-validation avec Leave-One-Out

Explication

Chaque exemple devient un fold. Cela signifie que si vous avez n données, il y aura n itérations.
À chaque itération, une seule donnée est utilisée pour le test, et le reste pour l’entraînement.

Figure 89 – Illustration de la méthode Leave-One-Out


1 # Cross - validation avec ShuffleSplit
2 c ro ss _ va l_ s co r e ( estimateur , X_train , y_train , cv = ShuffleSplit (4 , test_size =0.2) )

Listing 132 – Cross-validation avec ShuffleSplit

Explication

Divise aléatoirement les données en ensembles d’entraînement et de test, répété 4 fois. Chaque
fois, 20% des données sont utilisées pour le test, et le reste pour l’entraînement.

BDCC-S3-2024-2025 91 Mohamed Ouazze

5 MACHINE LEARNING

Figure 90 – Illustration de la méthode ShuffleSplit

5.11 Les erreurs

5.11.1 L’Erreur Quadratique Moyenne ou Mean Squared Error (MSE)

Explication

L’erreur quadratique moyenne est une métrique couramment utilisée pour évaluer la performance
des modèles de régression en apprentissage automatique.
n
1X
MSE = (yi − ŷi )2 (1)
n i=1
où :
— n : Nombre de données (échantillons).
— yi : Valeur réelle (observée) pour l’échantillon i.
— ŷi : Prédiction du modèle pour l’échantillon i.

Exercice

Valeurs réelles (yi ) : [3, 5, 2]

Valeurs prédites (ŷi ) : [4, 4, 3]

1
MSE = [(3 − 4)2 + (5 − 4)2 + (2 − 3)2 ]
3
1
= · (1 + 1 + 1)
3
=1

5.11.2 Root Mean Squared Error (RMSE)

Explication

Plus facile à interpréter que le MSE, c’est la racine carrée de l’erreur quadratique moyenne.
v
u n
√ u1 X
RMSE = MSE = t (yi − ŷi )2 (2)
n i=1

BDCC-S3-2024-2025 92 Mohamed Ouazze

5 MACHINE LEARNING

Exercice
Considérons un nouvel ensemble de valeurs réelles et prédites :

Valeur réelle (y) Valeur prédite (ŷ)

10 8
12 15
14 13

Table 2 – Valeurs pour l’exemple de calcul MSE et RMSE

Solution
1. Calcul des erreurs :
— Pour y1 = 10, ŷ1 = 8 : erreur = (10 − 8)2 = 22 = 4
— Pour y2 = 12, ŷ2 = 15 : erreur = (12 − 15)2 = (−3)2 = 9
— Pour y3 = 14, ŷ3 = 13 : erreur = (14 − 13)2 = 12 = 1
2. Calcul du MSE :
4+9+1
MSE =
3
14
=
3
≈ 4.67

3. Calcul du RMSE :
√
RMSE = MSE
√
= 4.67
≈ 2.16

5.11.2.1 Interprétation
— MSE : La valeur de MSE est d’environ 4.67, exprimée dans les unités au carré de la variable
cible.
— RMSE : La valeur de RMSE est d’environ 2.16, ce qui est plus facile à interpréter car elle
est dans les mêmes unités que les valeurs réelles.

5.11.2.2 Conclusion Cet exemple montre comment le MSE et le RMSE peuvent avoir des
valeurs différentes, mais ils mesurent tous deux la même chose : l’erreur entre les valeurs prédites
et réelles. Le RMSE est souvent préféré pour son interprétabilité directe, tandis que le MSE peut
être utilisé pour des analyses plus techniques.

5.11.3 Mean Absolute Error (MAE)

Explication

Erreur absolue moyenne. Utilise la valeur absolue au lieu du carré, donc moins sensible aux grandes
erreurs. Donne une vision globale des écarts moyens.
n
1X
MAE = |yi − ŷi | (3)
n i=1

BDCC-S3-2024-2025 93 Mohamed Ouazze

5 MACHINE LEARNING

Exercice

5.11.3.1 Exemple Numérique : Calcul de l’Erreur Absolue Moyenne (MAE) Consi-

dérons le même ensemble de valeurs réelles et prédites :

Valeur réelle (y) Valeur prédite (ŷ)

10 8
12 15
14 13

Table 3 – Valeurs pour l’exemple de calcul MAE

Solution
1. Calcul des erreurs absolues :
— Pour y1 = 10, ŷ1 = 8 : erreur absolue = |10 − 8| = |2| = 2
— Pour y2 = 12, ŷ2 = 15 : erreur absolue = |12 − 15| = | − 3| = 3
— Pour y3 = 14, ŷ3 = 13 : erreur absolue = |14 − 13| = |1| = 1
2. Calcul du MAE :
2+3+1
MAE =
3
6
=
3
=2

Explication

5.11.3.2 Interprétation Le MAE est une mesure de l’erreur moyenne entre les valeurs
réelles et les valeurs prédites. Dans cet exemple, le MAE est de 2, ce qui signifie qu’en
moyenne, les prédictions sont à 2 unités de la valeur réelle.
5.11.3.3 Conclusion Le MAE donne une compréhension de l’amplitude moyenne des
erreurs. Contrairement au MSE et RMSE, il n’élève pas les erreurs au carré, ce qui fait
qu’il est moins sensible aux grandes erreurs individuelles.

BDCC-S3-2024-2025 94 Mohamed Ouazze

5 MACHINE LEARNING

5.12 Analyse de la Performance des Modèles

5.12.1 Coefficient de Détermination (R2 )

Explication

Le coefficient de détermination, noté R2 , est une mesure statistique qui évalue l’efficacité d’un
modèle de régression linéaire. Il quantifie la proportion de la variance de la variable dépendante
qui est expliquée par les variables indépendantes.
SSrésidu
R2 = 1 − (4)
SStotal

5.12.1.1 Propriétés de R2
— Valeurs possibles : R2 varie entre 0 et 1.
— Interprétation : Plus R2 est proche de 1, meilleure est l’adéquation du modèle aux don-
nées.
— Limites : L’ajout de variables peut artificiellement augmenter R2 . Pour remédier à cela,
on utilise souvent le R2 ajusté.

5.12.2 Précision et Rappel

Explication

La précision et le rappel sont deux métriques essentielles pour évaluer la performance des modèles
de classification.

5.12.2.1 Précision La précision mesure la proportion d’exemples correctement classés comme

positifs parmi tous ceux classés comme positifs.
Vrais Positifs
Précision = (5)
Vrais Positifs + Faux Positifs

5.12.2.2 Rappel Le rappel mesure la proportion d’exemples positifs correctement identifiés

par le modèle.
Vrais Positifs
Rappel = (6)
Vrais Positifs + Faux Négatifs

5.12.2.3 Importance du Compromis Ces deux métriques sont souvent utilisées ensemble
pour donner une vue d’ensemble sur la performance du modèle, en particulier à travers la courbe
précision-rappel.

BDCC-S3-2024-2025 95 Mohamed Ouazze

5 MACHINE LEARNING

5.12.3 F1-score

Explication

Le F1-score est une métrique essentielle pour évaluer la performance des modèles de classification,
en particulier dans les cas où les classes sont déséquilibrées. Il représente un compromis entre la
précision et le rappel.

5.12.3.1 Définition du F1-score Le F1-score est défini comme la moyenne harmonique de

la précision et du rappel :
2 précision · rappel
F1-score = =2· (7)
1
précision + 1
rappel
précision + rappel

5.12.3.2 Interprétation
— Valeurs possibles : Le F1-score varie entre 0 et 1. Un score de 1 indique une précision et
un rappel parfaits.
— Utilisation : Il est particulièrement utile dans des contextes tels que la détection de fraudes
ou la classification de maladies.

Explication

5.12.3.3 Comparaison des Métriques Voici un tableau récapitulatif des différentes mé-
triques discutées :

Métrique Formule Interprétation

Coefficient R2 R2 = 1 − SSSSrésidu
total
Proportion de variance expliquée par le modèle
Précision Précision = Vrais Positifs+Faux
Vrais Positifs
Positifs Taux de prédictions positives correctes
Rappel Rappel = Vrais Positifs+Faux
Vrais Positifs
Négatifs Taux de positifs correctement identifiés
F1-score F1-score = 1
2
1 Moyenne harmonique de précision et rappel
précision + rappel

5.13 Analyse de la Matrice de Confusion

5.13.1 Matrice de Confusion

Explication

5.13.1.1 La matrice de confusion La matrice de confusion donnée est :

Réel 0 Réel 1 Réel 2
Prédit 0 8 0 0
Prédit 1 0 9 0
Prédit 2 0 2 11

Matrice de confusion pour un problème à trois classes

5.13.1.2 Éléments de la Matrice

— Vrais Positifs (TP) : Cas correctement classifiés comme appartenant à une classe.
— Faux Positifs (FP) : Cas incorrectement classés comme appartenant à une classe.
— Faux Négatifs (FN) : Cas qui appartiennent réellement à une classe mais qui ont été
classés dans une autre.

BDCC-S3-2024-2025 96 Mohamed Ouazze

5 MACHINE LEARNING

5.13.2 Calcul des Métriques

Solution

5.13.2.1 Pour la Classe 0

— T P0 = 8
— F P0 = 0 + 0 = 0 (aucun faux positif pour la classe 0)
— F N0 = 0 + 0 = 0 (aucun faux négatif pour la classe 0)
Précision
T P0
Précision0 =
T P0 + F P0
8
=
8+0
= 1.00

Rappel
T P0
Rappel0 =
T P0 + F N0
8
=
8+0
= 1.00

F1-score
2 × (Précision0 × Rappel0 )
F 10 =
Précision0 + Rappel0
2 × (1.00 × 1.00)
=
1.00 + 1.00
= 1.00

5.13.2.2 Pour la Classe 1

— T P1 = 9
— F P1 = 2 (prédit comme classe 1 mais réel est classe 2)
— F N1 = 0 (aucun faux négatif pour la classe 1)
Précision
T P1
Précision1 =
T P1 + F P1
9
=
9+2
9
=
11
≈ 0.82

Rappel
T P1
Rappel1 =
T P1 + F N1
9
=
9+0
= 1.00

F1-score
2 × (Précision1 × Rappel1 )
F 11 =
Précision1 + Rappel1
2 × (0.82 × 1.00)
=
0.82 + 1.00
2(0.82)
=
BDCC-S3-2024-2025 1.82 97 Mohamed Ouazze
≈ 0.90
5 MACHINE LEARNING

Solution

5.13.2.3 Pour la Classe 2

— T P2 = 11
— F P2 = 2 (prédit comme classe 2 mais réel est classe 1)
— F N2 = 0 (aucun faux négatif pour la classe 2)
Précision
T P2 11 11
Précision2 = = = ≈ 0.85
T P2 + F P2 11 + 2 13
Rappel
T P2 11
Rappel2 = = = 1.00
T P2 + F N2 11 + 0
F1-score
2 × (Précision2 × Rappel2 ) 2 × (0.85 × 1.00)
F 12 = = = 0.91
Précision2 + Rappel2 0.85 + 1.00

5.13.2.4 Résumé des Résultats

Classe Précision Rappel F1-score

Classe 0 1.00 1.00 1.00
Classe 1 0.82 1.00 0.90
Classe 2 0.85 1.00 0.91

Récapitulatif des métriques par classe

5.13.2.5 Conclusion Ces calculs montrent comment évaluer les performances d’un modèle de
classification en utilisant une matrice de confusion pour extraire des métriques clés telles que la
précision, le rappel et le F1-score pour chaque classe.

5.14 Exemple de Matrice de Confusion pour une Classification à 3 Classes

5.14.1 Matrice de Confusion

Explication

Voici un exemple de matrice de confusion pour notre modèle :

Réel Pomme Réel Orange Réel Banane

Prédit Pomme 50 (TP) 5 (FP) 0 (FP)
Prédit Orange 2 (FN) 45 (TP) 4 (FP)
Prédit Banane 1 (FN) 3 (FN) 40 (TP)

Matrice de confusion pour la classification de fruits

5.14.1.1 Interprétation des Valeurs

— TP Pomme = 50 : Le modèle a correctement prédit que 50 pommes étaient des pommes.
— FN Pomme = 3 : Le modèle a manqué de prédire 3 pommes qui ont été classées comme
oranges ou bananes.
— FP Pomme = 5 : Le modèle a prédit que 5 oranges étaient des pommes.

BDCC-S3-2024-2025 98 Mohamed Ouazze

5 MACHINE LEARNING

5.14.2 Calcul des Métriques

Solution

À partir de cette matrice, nous pouvons calculer plusieurs métriques importantes pour chaque
classe.

5.14.2.1 Pour la Classe Pomme

1. Précision :
T PPomme 50 50
PrécisionPomme = = = ≈ 0.91 (8)
T PPomme + F PPomme 50 + 5 55

2. Rappel :
T PPomme 50 50
RappelPomme = = = ≈ 0.94 (9)
T PPomme + F NPomme 50 + 3 53
3. F1-score :
2 × (0.91 × 0.94) 2 × 0.8554
F 1Pomme = = ≈ 0.92 (10)
0.91 + 0.94 1.85

5.14.2.2 Pour la Classe Orange

1. Précision :
45 45
PrécisionOrange = = ≈ 0.92 (11)
45 + 4 49
2. Rappel :
45 45
RappelOrange = = = 0.90 (12)
45 + 5 50
3. F1-score :
2 × (0.92 × 0.90) 2 × 0.828
F 1Orange = = ≈ 0.91 (13)
0.92 + 0.90 1.82

5.14.2.3 Pour la Classe Banane

1. Précision :
40 40
PrécisionBanane = = ≈ 0.91 (14)
40 + 4 44
2. Rappel :
40 40
RappelBanane = = ≈ 0.91 (15)
40 + 4 44
3. F1-score :
2 × (0.91 × 0.91) 2 × 0.8281
F 1Banane = = ≈ 0.91 (16)
0.91 + 0.91 1.82

5.14.2.4 Résumé des Résultats

Classe Précision Rappel F1-score

Pomme 0.91 0.94 0.92
Orange 0.92 0.90 0.91
Banane 0.91 0.91 0.91

5.14.2.5 Conclusion Cet exemple illustre comment les concepts de TP, FP, FN et TN peuvent
être utilisés pour évaluer les performances d’un modèle de classification multi-classes à l’aide d’une
matrice de confusion, en calculant les métriques clés pour chaque classe.

BDCC-S3-2024-2025 99 Mohamed Ouazze

5 MACHINE LEARNING

5.15 Prétraitement des Données avec Sklearn

5.15.1 Encodage des Données Catégorielles

Explication

Le prétraitement des données représente parfois jusqu’à 80% du travail d’un data scientist. Une
étape clé consiste à convertir les variables qualitatives (catégorielles) en valeurs numériques
exploitables par les algorithmes de machine learning.

5.15.2 Techniques d’Encodage dans Sklearn

Explication

Voici les principales transformations d’encodage disponibles dans sklearn :

— LabelBinarizer
— LabelEncoder
— MultiLabelBinarizer
— OneHotEncoder
— OrdinalEncoder

5.15.3 Encodage avec LabelEncoder et LabelBinarizer

Explication

L’Encodage avec LabelEncoder et LabelBinarizer permet d’associer à chaque catégorie une

valeur numérique unique.

5.15.3.1 Exemple : On dispose du vecteur suivant :

y = [’chat’, ’chien’, ’chat’, ’oiseau’]

BDCC-S3-2024-2025 100 Mohamed Ouazze

5 MACHINE LEARNING

Solution
1. Utilisation de LabelEncoder

1 import numpy as np
2 from sklearn . preprocessing import LabelEncoder
3
4 # D o n n e s de d p a r t
5 y = np . array ([ ’ chat ’ , ’ chien ’ , ’ chat ’ , ’ oiseau ’ ])
6
7 # C r a t i o n de l ’ encodeur
8 encoder = LabelEncoder ()
9
10 # Apprentissage des classes et tr ansfor mation
11 enc oded_l abels = encoder . fit_transform ( y )
12
13 print ( enc oded_l abels )
14

Résultat :
array([0, 1, 0, 2], dtype=int64)
Chaque animal est associé à un entier :
— chat → 0
— chien → 1
— oiseau → 2
2. Décodage inverse (reconnaître les classes)

1 # D c o d a g e inverse
2 dec oded_l abels = encoder . i n v e r s e _ t r a n s f o r m ( np . array ([0 , 0 , 2]) )
3 print ( dec oded_l abels )
4

Résultat :
array([’chat’, ’chat’, ’oiseau’], dtype=’<U6’)
Cela permet de retrouver les classes originales à partir des indices numériques.

BDCC-S3-2024-2025 101 Mohamed Ouazze

5 MACHINE LEARNING

5.15.4 Utilisation de OneHotEncoder

Solution
Contrairement à LabelEncoder, OneHotEncoder transforme chaque catégorie en un vecteur bi-
naire.

1 from sklearn . preprocessing import OneHotEncoder
2
3 # Reshape des d o n n e s ( OneHotEncoder attend des d o n n e s 2 D )
4 X = y . reshape ( -1 , 1)
5
6 # C r a t i o n de l ’ encodeur
7 oneh ot_enc oder = OneHotEncoder ()
8
9 # Transf ormati on des d o n n e s
10 encoded_data = one hot_en coder . fit_transform ( X )
11
12 # Conversion du r s u l t a t en tableau NumPy
13 result_array = encoded_data . toarray ()
14
15 print ( " R s u l t a t en tableau NumPy : " )
16 print ( result_array )

Explication des étapes :

— reshape(-1,1) : Convertit le tableau 1D en 2D, attendu par OneHotEncoder.
— fit_transform : Apprend les catégories et applique l’encodage.
— toarray() : Convertit la matrice sparse en un tableau dense NumPy.

Résultat obtenu :  
1. 0. 0. 0. 1.
 
 
0. 1. 0. 0. 1.
 
 
1. 0. 0. 0. 1.
 
0. 0. 1. 1. 0.
Chaque ligne représente une instance, chaque colonne une catégorie :
— 1 signifie présence de la classe,
— 0 signifie absence.

5.15.5 Résumé

Explication

— LabelEncoder : encode les catégories en nombres entiers.

— OneHotEncoder : encode les catégories en vecteurs binaires (0/1).
— LabelBinarizer : similaire à OneHotEncoder mais pour des labels 1D.
— OrdinalEncoder : encode en entiers ordonnés.
— MultiLabelBinarizer : pour des listes de catégories multiples.

L’encodage est une étape fondamentale avant d’entraîner un modèle de Machine Learning.

5.16 Normalisation
Explication

La normalisation est une technique utilisée pour ajuster les valeurs des données afin qu’elles
soient dans une plage commune, souvent entre 0 et 1. C’est crucial pour les algorithmes de machine
learning sensibles à l’échelle des données.

BDCC-S3-2024-2025 102 Mohamed Ouazze

5 MACHINE LEARNING

5.16.1 Techniques de Normalisation avec Sklearn

Explication

Nous allons utiliser les méthodes suivantes :

— MinMaxScaler
— StandardScaler (z-score)
— RobustScaler

1 from sklearn . preprocessing import MinMaxScaler , StandardScaler , RobustScaler
2 from sklearn . datasets import load_iris
3 import matplotlib . pyplot as plt
4
5 # Chargement du dataset Iris
6 iris = load_iris ()
7 X = iris . data

5.16.2 MinMaxScaler

Solution

Le MinMaxScaler réduit les données dans une plage donnée (par défaut entre 0 et 1), selon la
formule :
X − Xmin
Xscaled =
Xmax − Xmin
Exemple :
Pour des âges [20, 30, 40, 50, 60], l’âge 30 serait normalisé comme suit :
30 − 20 10
Xscaled = = = 0.25
60 − 20 40

Application sur le dataset Iris :


1 # Normalisation MinMax
2 X_minmax = MinMaxScaler () . fit_transform ( X )
3
4 # Visualisation avant et a p r s
5 plt . scatter ( X [: , 2] , X [: , 3] , label = ’ Original ’)
6 plt . scatter ( X_minmax [: , 2] , X_minmax [: , 3] , label = ’ MinMax N o r m a l i s ’)
7 plt . legend ()
8 plt . title ( " MinMaxScaler " )
9 plt . show ()

Figure 91 – Comparaison avant/après normalisation avec MinMaxScaler

BDCC-S3-2024-2025 103 Mohamed Ouazze

5 MACHINE LEARNING

5.16.3 StandardScaler (Z-score)

Solution
Le StandardScaler transforme les données pour qu’elles aient :
— une moyenne de 0,
— un écart-type de 1.
La formule est :
X −µ
Xstandardisé =
σ
où :
— X : valeur originale
— µ : moyenne
— σ : écart-type
Exemple :
Pour des âges [20, 30, 40, 50, 60] :
20 + 30 + 40 + 50 + 60
µ= = 40
5
r
(20 − 40)2 + (30 − 40)2 + (40 − 40)2 + (50 − 40)2 + (60 − 40)2
σ= ≈ 14.14
5
Pour l’âge 30 :
30 − 40
Xstandardisé = ≈ −0.707
14.14
Application sur le dataset Iris :

1 # S ta n da rd i sa ti o n
2 X_stdscl = Stand ardSca ler () . fit_transform ( X )
3
4 # Visualisation
5 plt . scatter ( X [: , 2] , X [: , 3] , label = ’ Original ’)
6 plt . scatter ( X_stdscl [: , 2] , X_stdscl [: , 3] , label = ’ S t a n d a r d i s ’)
7 plt . legend ()
8 plt . title ( " St andard Scaler " )
9 plt . show ()

Figure 92 – Comparaison avant/après normalisation avec Standar Scaler

BDCC-S3-2024-2025 104 Mohamed Ouazze

5 MACHINE LEARNING

5.16.4 RobustScaler

Solution

Le RobustScaler est une méthode plus robuste face aux valeurs aberrantes (outliers). Il utilise
la médiane et l’écart interquartile (IQR) pour transformer les données.
La formule est :
X − médiane
Xrobust =
IQR
où :

IQR = Q3 − Q1
(Q1 = 25% percentile, Q3 = 75% percentile)
Exemple :
Pour des âges [20, 30, 40, 50, 1000] :
— Médiane = 40
— Q1 = 30
— Q3 = 50
— IQR = 50 - 30 = 20
Pour l’âge 30 :
30 − 40
Xrobust = = −0.5
20

Application sur le dataset Iris :


1 # Normalisation robuste
2 X_robust = RobustScaler () . fit_transform ( X )
3
4 # Visualisation
5 plt . scatter ( X [: , 2] , X [: , 3] , label = ’ Original ’)
6 plt . scatter ( X_robust [: , 2] , X_robust [: , 3] , label = ’ Robust N o r m a l i s ’)
7 plt . legend ()
8 plt . title ( " RobustScaler " )
9 plt . show ()

Figure 93 – Comparaison avant/après normalisation avec Robust Scaler

BDCC-S3-2024-2025 105 Mohamed Ouazze

5 MACHINE LEARNING

5.16.5 Conclusion

Explication

— MinMaxScaler : normalise entre 0 et 1 (ou autre plage spécifiée).

— StandardScaler : standardise avec moyenne 0 et écart-type 1.
— RobustScaler : robuste aux valeurs extrêmes en utilisant médiane et IQR.
La sélection de la méthode dépend de la nature des données et de la sensibilité aux valeurs
extrêmes.

5.17 Polynomial Features

Les Polynomial Features (caractéristiques polynomiales) sont une méthode utilisée pour augmenter
la complexité des modèles de régression et d’autres algorithmes de machine learning. Cela permet de
capturer des relations non linéaires entre les variables d’entrée.

Explication

Exemple :
(x0 , x1 , x2 ) pour les valeurs suivantes [1, 2, 0.5]

x0 x1 x2
1 1 1
1 2 4
1 0.5 0.25

1 from sklearn . preprocessing import P o l y n o m i a l F e a t u r e s
2 from sklearn . linear_model import L i n e a r R e g r e s s i o n
3
4 m = 100
5 X = np . linspace (0 , 4 , m ) . reshape (( m , 1) )
6 y = X **2 + 5* np . cos ( X ) + np . random . randn (m , 1)
7
8 model = L i n e a r R e g r e s s i o n () . fit (X , y )
9 y_pred = model . predict ( X )
10
11 plt . scatter (X , y )
12 plt . plot (X , y_pred , c = ’r ’ , lw =3)

Le code ci-dessus génère des données X avec une relation quadratique, ajoutée à une composante
aléatoire (bruit) dans y. Un modèle de régression linéaire est ensuite ajusté aux données (X, y),
et la prédiction est tracée avec la ligne rouge pour comparer la sortie du modèle avec les points
de données réels.

Figure 94 – avant crée polyno

BDCC-S3-2024-2025 106 Mohamed Ouazze

5 MACHINE LEARNING

Explication

Après transformation polynomiale :


1 X_poly = P o l y n o m i a l F e a t u r e s (3) . fit_transform ( X )
2 model = L i n e a r R e g r e s s i o n () . fit ( X_poly , y )
3 y_pred = model . predict ( X_poly )
4
5 plt . scatter (X , y )
6 plt . plot (X , y_pred , c = ’r ’ , lw =3)

Ici, la transformation polynomiale est appliquée avec un degré de 3, ce qui crée des caractéristiques
supplémentaires (x2 , x3 , etc.). Le modèle de régression linéaire est maintenant ajusté sur ces
nouvelles caractéristiques polynomiales, ce qui permet au modèle de capturer une relation plus
complexe entre les données.

Figure 95 – Apré crée polyno

BDCC-S3-2024-2025 107 Mohamed Ouazze

5 MACHINE LEARNING

5.18 Discrétisation
La discrétisation est le processus de transformation de données continues (c’est-à-dire des données
numériques qui peuvent prendre une large gamme de valeurs) en catégories ou classes distinctes. Cela
consiste à diviser une variable continue en plusieurs intervalles ou bins (groupes) pour la rendre plus facile
à traiter, en particulier dans des modèles qui fonctionnent mieux avec des données catégorielles.

BDCC-S3-2024-2025 108 Mohamed Ouazze

5 MACHINE LEARNING

Explication

Exemple avec Binarizer et KBinsDiscretizer :


1 from sklearn . preprocessing import Binarizer , K B i n s D i s c r e t i z e r
2 X = np . linspace (0 , 5 , 10) . reshape ((10 , 1) )
3 np . hstack (( X , Binarizer ( threshold =3) . fit_transform ( X ) ) )

Le Binarizer transforme les valeurs continues en 0 ou 1 en fonction d’un seuil défini. Dans cet
exemple, les valeurs de X supérieures ou égales à 3 sont transformées en 1, et les autres en 0. Cela
permet de convertir une variable continue en une variable binaire.
Résultat :
X Discretized
0.0 0
0.56 0
1.11 0
1.67 0
2.22 0
2.78 0
3.33 1
3.89 1
4.44 1
5.0 1

1 K B i n s D i s c r e t i z e r ( n_bins =6) . fit_transform ( X ) . toarray ()

Le KBinsDiscretizer divise les données en 6 groupes égaux, transformant ainsi les valeurs conti-
nues en vecteurs binaires où chaque colonne représente un intervalle dans lequel la valeur d’origine
se situe. C’est une manière de convertir des variables continues en variables catégorielles avec
plusieurs classes.
Résultat :
1.0 0.0 0.0 0.0 0.0 0.0
1.0 0.0 0.0 0.0 0.0 0.0
0.0 1.0 0.0 0.0 0.0 0.0
0.0 0.0 1.0 0.0 0.0 0.0
0.0 0.0 1.0 0.0 0.0 0.0
0.0 0.0 0.0 1.0 0.0 0.0
0.0 0.0 0.0 0.0 1.0 0.0
0.0 0.0 0.0 0.0 1.0 0.0
0.0 0.0 0.0 0.0 0.0 1.0
0.0 0.0 0.0 0.0 0.0 1.0

BDCC-S3-2024-2025 109 Mohamed Ouazze

5 MACHINE LEARNING

5.19 Pipelines
Une pipeline (pipeline de machine learning) est une série d’étapes ou de transformations appliquées
aux données, suivies d’un modèle d’apprentissage automatique. Elle permet de simplifier et d’automatiser
le processus de préparation des données, de transformation et de modélisation, tout en s’assurant que
toutes les étapes nécessaires sont correctement enchaînées.

Explication

Pour créer une pipeline, on a deux options :

— Classe Pipeline
— Fonction make_pipeline()

1 from sklearn . pipeline import make_pipeline
2 from sklearn . linear_model import SGDClassifier
3 from sklearn . m od el _ se le c ti on import t r a i n _ t e s t _ s p l i t
4
5 X = iris . data
6 y = iris . target
7
8 X_train , X_test , y_train , y_test = t r a i n _ t e s t _ s p l i t (X , y , random_state =0)
9 model = make_pipeline ( St andard Scaler () , SGDClassifier () )
10
11 model . fit ( X_train , y_train )
12 model . score ( X_test , y_test )

Dans ce code, un pipeline est créé avec make_pipeline en enchaînant deux étapes :
StandardScaler() pour la normalisation des données et SGDClassifier() pour l’apprentissage
supervisé. Le modèle est ensuite ajusté et évalué sur les ensembles d’entraînement et de test.
Résultat :
Score : 0.9736842105263158

5.20 Pipeline avec GridSearchCV

On peut utiliser GridSearchCV pour trouver les meilleurs paramètres de la pipeline.

Explication

1 from sklearn . m od el _ se le c ti on import GridSearchCV
2
3 model = make_pipeline ( P o l y n o m i a l F e a t u r e s () ,
4 Sta ndardS caler () ,
5 SGDClassifier ( random_state =0) )
6
7 params = {
8 ’ p o l y n o m i a l f e a t u r e s _ _ d e g r e e ’: [2 , 3 , 4] ,
9 ’ s g d c l a s s i f i e r _ _ p e n a l t y ’: [ ’ l1 ’ , ’ l2 ’]
10 }
11
12 grid = GridSearchCV ( model , param_grid = params , cv =4)
13 grid . fit ( X_train , y_train )

Dans ce code, nous utilisons GridSearchCV pour tester différentes combinaisons d’hyperparamètres
pour les caractéristiques polynomiales et le classificateur SGD. Nous cherchons les meilleures
configurations de modèle en utilisant la validation croisée (cv=4).
Résultat du GridSearchCV :

GridSearchCV avec score : 0.9736842105263158

BDCC-S3-2024-2025 110 Mohamed Ouazze

5 MACHINE LEARNING

Figure 96 – Pipline avec Grid SearchCV

5.21 Pipeline Avance

Pour traiter des datasets hétérogènes, c’est-à-dire les datasets qui contiennent différents types de
variables (descriptives, continues, catégoriques) dans le but de créer des modèles adaptés, plusieurs outils
sont disponibles.

Explication

5.21.1 make_column_selector
make_column_selector est une fonction utilisée pour sélectionner des colonnes d’un DataFrame
en fonction de leur type (numérique, catégorielle, etc.). Elle est utile pour spécifier dynamiquement
quelles colonnes transformer dans un pipeline.
5.21.2 make_union
make_union permet de combiner plusieurs transformations dans une seule étape de pipeline. Elle
applique les transformations spécifiées à toutes les colonnes et les fusionne ensuite dans une seule
sortie.
5.21.3 Pipelines avec nettoyage de données
— SimpleImputer : dans sklearn.imputer on a cette méthode qui remplace les valeurs
manquantes par une valeur statistique.

1 Imputer = SimpleImputer ( m issing _value s = np . nan , strategy = ’ ’)
2 # strategy = [ mean , median , most_frequent .. ]
3

— KNNImputer : remplace toutes les valeurs manquantes par les valeurs du plus proche
voisin.
— MissingIndicator : parfois l’absence de données est une information en soi et représente
une caractéristique.

BDCC-S3-2024-2025 111 Mohamed Ouazze

5 MACHINE LEARNING

Explication

1 from sklearn . impute import SimpleImputer
2 from sklearn . preprocessing import StandardScaler , OneHotEncoder
3 from sklearn . pipeline import make_pipeline
4 from sklearn . compose import C o l u m n T r a n s f o r m e r
5 from sklearn . linear_model import SGDClassifier
6 from sklearn . m od el _ se le c ti on import t r a i n _ t e s t _ s p l i t
7 import pandas as pd
8
9 # Exemple de DataFrame
10 data = {
11 ’ column1 ’: [1 , 2 , 3 , 4 , 5 , None , 7] ,
12 ’ column2 ’: [2 , 3 , 4 , None , 6 , 7 , 8] ,
13 ’ column3 ’: [ ’A ’ , ’B ’ , ’A ’ , ’B ’ , ’A ’ , ’A ’ , ’B ’] , # Colonne c a t g o r i e l l e
14 ’ column4 ’: [ ’X ’ , ’Y ’ , ’X ’ , ’Y ’ , ’X ’ , ’X ’ , ’Y ’] , # Autre colonne c a t g o r i e l l e
15 ’ target ’: [0 , 1 , 0 , 1 , 0 , 1 , 0]
16 }
17
18 # C r e r un DataFrame
19 df = pd . DataFrame ( data )
20
21 # S p a r e r les c a r a c t r i s t i q u e s ( X ) et la cible ( y )
22 X = df . drop ( ’ target ’ , axis =1)
23 y = df [ ’ target ’]
24
25 # Variables n u m r i q u e s et c a t g o r i e l l e s
26 numeric_vars = [ ’ column1 ’ , ’ column2 ’]
27 c a t e g o r i ca l _ v a r s = [ ’ column3 ’ , ’ column4 ’]
28
29 # Pipeline pour les variables n u m r i q u e s
30 n u m e r i c _ pi p e l i n e = make_pipeline (
31 SimpleImputer () , # Imputer les valeurs manquantes
32 Stan dardSc aler () # Normalisation des d o n n e s n u m r i q u e s
33 )
34
35 # Pipeline pour les variables c a t g o r i e l l e s
36 c a t e g o r i c a l _ p i p e l i n e = make_pipeline (
37 SimpleImputer ( strategy = ’ most_frequent ’) , # Imputer les valeurs manquantes avec
la m o d a l i t la plus f r q u e n t e
38 OneHotEncoder () # Encoder les variables c a t g o r i e l l e s
39 )
40
41 # P r p r o c e s s e u r utilisant C o l u m n T r a n s f o r m e r
42 preprocessor = C o l u m n T r a n s f o r m e r (
43 transformers =[
44 ( ’ num ’ , numeric_pipeline , numeric_vars ) , # Applique la pipeline des
variables n u m r i q u e s
45 ( ’ cat ’ , categorical_pipeline , c a t e g o r i c a l _ v a r s ) # Applique la pipeline des
variables c a t g o r i e l l e s
46 ]
47 )
48
49 # M o d l e de machine learning avec le p r p r o c e s s e u r
50 model = make_pipeline (
51 preprocessor , # Appliquer le p r p r o c e s s e u r avant d ’ e n t r a n e r le m o d l e
52 SGDClassifier () # M o d l e d ’ apprentissage ( ici , SGDClassifier )
53 )
54
55 # Diviser les d o n n e s en ensembles d ’ e n t r a n e m e n t et de test
56 X_train , X_test , y_train , y_test = t r a i n _ t e s t _ s p l i t (X , y , test_size =0.3 ,
random_state =42)
57
58 # E n t r a n e r le m o d l e
59 model . fit ( X_train , y_train )
60
61 # valuer le m o d l e sur les d o n n e s de test
62 accuracy = model . score ( X_test , y_test )
63 print ( f " Accuracy sur les d o n n e s de test : { accuracy :.2 f } " )

BDCC-S3-2024-2025 112 Mohamed Ouazze

5 MACHINE LEARNING

Explication

Dans cet exemple, nous construisons un pipeline complet pour traiter un dataset hétérogène.
Le préprocesseur utilise ColumnTransformer pour appliquer des transformations différentes aux
variables numériques et catégorielles. Pour les variables numériques, nous imputons les valeurs
manquantes et standardisons les données, tandis que pour les variables catégorielles, nous imputons
les valeurs manquantes avec la modalité la plus fréquente et appliquons un encodage one-hot. Les
étapes clés sont :
1. Séparation des variables numériques et catégorielles
2. Création de pipelines spécifiques pour chaque type de variable
3. Combinaison des pipelines avec ColumnTransformer
4. Intégration du préprocesseur dans un pipeline final avec le modèle
Ce type de pipeline est particulièrement utile pour les datasets du monde réel qui contiennent
souvent différents types de variables et des valeurs manquantes.

5.22 Feature Selection

La sélection de caractéristiques (Feature selection) permet de trouver les variables les plus utiles pour
notre modèle de machine learning, ce qui améliore les performances et réduit la complexité.

Explication

Il existe plusieurs approches pour la sélection de caractéristiques :

— Variance Threshold : sélectionne les variables selon leur degré de variance.
— Test de dépendance : sélectionne les variables à partir d’un test statistique.
— Transformations basées sur des modèles : sélectionne les variables à partir des coef-
ficients d’un modèle entraîné sur un dataset (e.g., SelectFromModel, RFE, RFECV).

1 import numpy as np
2 import matplotlib . pyplot as plt
3 import pandas as pd

5.22.1 Variance Threshold

Explication

Cette méthode élimine les variables dont la variance est inférieure à un certain seuil. Pour effectuer
des prédictions, un estimateur a besoin d’informations qui varient en accord avec la variable target.

1 from sklearn . f e a t u r e _ s e l e c t i o n import V a r i a n c e T h r e s h o l d
2 from sklearn . datasets import load_iris
3
4 iris = load_iris ()
5 X = iris . data
6 y = iris . target
7
8 plt . plot ( X )
9 plt . legend ( iris . feature_names )

BDCC-S3-2024-2025 113 Mohamed Ouazze

5 MACHINE LEARNING

Figure 97 – cartérstique de iris

Explication

Examinons la variance de chaque caractéristique :


1 X . var ( axis =0)

Résultat :
array([0.68112222, 0.18871289, 3.09550267, 0.57713289])
Maintenant, appliquons un seuil de variance pour sélectionner les caractéristiques :

1 selector = V a r i a n c e T h r e s h o l d ( threshold =0.2)
2 selector . fit ( X )

Résultat :
VarianceThreshold(threshold=0.2)
Voyons quelles caractéristiques ont été sélectionnées :

1 selector . get_support ()

Résultat :

array([ True, False, True, True])

Les noms des caractéristiques retenues :

1 np . array ( iris . feature_names ) [ selector . get_support () ]

Résultat :
array([’sepal length (cm)’, ’petal length (cm)’, ’petal width (cm)’], dtype=’<U17’)

BDCC-S3-2024-2025 114 Mohamed Ouazze

5 MACHINE LEARNING

Explication

Les valeurs de variance calculées :


1 selector . variances_

Résultat :
array([0.68112222, 0.18871289, 3.09550267, 0.57713289])
La méthode VarianceThreshold a éliminé la caractéristique sepal width (cm) car sa variance
(0.189) est inférieure au seuil fixé (0.2). Les trois autres caractéristiques ont été conservées car
leurs variances sont supérieures au seuil. Cette méthode est utile pour éliminer les caractéristiques
qui varient peu et qui, par conséquent, apportent peu d’information au modèle.

5.22.2 SelectKBest

Explication

Cette méthode sélectionne les K variables dans X dont le score du test de dépendance avec y est
le plus élevé.
Exemple : la fonction chi2(x,y) retourne deux tableaux numpy :
1. Les scores des variables (plus le score est élevé, plus la variable est significative)
2. Les p-valeurs (probabilité que la relation observée soit due au hasard)

1 from sklearn . f e a t u r e _ s e l e c t i o n import SelectKBest , chi2 , f_classif
2
3 chi2 (X , y )

Utilisons f_classif pour évaluer les caractéristiques et sélectionnons les 2 meilleures :


1 selector = SelectKBest ( f_classif , k =2)
2 selector . fit (X , y )
3 selector . scores_

Résultat :

array([ 119.26450218, 49.16004009, 1180.16118225, 960.0071468 ])

Les caractéristiques sélectionnées :

1 np . array ( iris . feature_names ) [ selector . get_support () ]

Résultat :
array([’petal length (cm)’, ’petal width (cm)’], dtype=’<U17’)
SelectKBest avec f_classif a sélectionné les deux caractéristiques ayant les scores F les plus
élevés : petal length (cm) et petal width (cm). Ces scores F indiquent que ces caractéristiques
ont une forte relation statistique avec la variable cible. La fonction f_classif utilise le test
ANOVA F pour évaluer la relation entre chaque caractéristique et la cible.

BDCC-S3-2024-2025 115 Mohamed Ouazze

5 MACHINE LEARNING

5.22.3 Recursive Feature Elimination

Explication

Cette méthode sélectionne les variables en se basant sur le coefficient d’un estimateur en l’en-
traînant de manière récursive. Elle élimine les variables selon les coefficients les plus faibles
de l’estimateur.

1 from sklearn . f e a t u r e _ s e l e c t i o n import RFECV
2 from sklearn . linear_model import SGDClassifier
3
4 selector = RFECV ( SGDClassifier ( random_state =0) , step =1 , m i n _ f e a t u r e s _ t o _ s e l e c t =2 ,
cv =5)
5 selector . fit (X , y )
6 print ( selector . ranking_ )
7 print ( selector . grid_scores_ )

Résultat :
[2 1 1 1]
[0.8 0.84666667 0.77333333]
Les caractéristiques sélectionnées :

1 np . array ( iris . feature_names ) [ selector . get_support () ]

Résultat :
array([’sepal width (cm)’, ’petal length (cm)’, ’petal width (cm)’], dtype=’<U17’)

RFECV (Recursive Feature Elimination with Cross-Validation) a attribué des rangs aux caractéris-
tiques (le rang 1 indique les caractéristiques sélectionnées et les rangs supérieurs indiquent l’ordre
d’élimination). Ici, sepal length (cm) a été éliminée (rang 2), tandis que les trois autres caracté-
ristiques ont été conservées. grid_scores_ montre les scores de validation croisée pour différents
nombres de caractéristiques. Dans ce cas, les meilleurs résultats ont été obtenus avec 3 caractéris-
tiques (score de 0.847). RFECV utilise la validation croisée pour déterminer automatiquement le
nombre optimal de caractéristiques à conserver.

BDCC-S3-2024-2025 116 Mohamed Ouazze

5 MACHINE LEARNING

5.22.4 SelectFromModel

Explication

Cette méthode préentraîne un estimateur et examine ses coefficients pour identifier les variables
importantes. Elle est plus compatible avec les modèles qui développent une fonction paramétrée
(avec des coefficients ou des noms de caractéristiques). Les modèles comme KNN sont incompa-
tibles car ils sont paramétrés avec les échantillons déjà vus et non avec des coefficients explicites.

1 from sklearn . f e a t u r e _ s e l e c t i o n import S e le ct F ro mM o de l
2
3 X = iris . data
4 y = iris . target
5 selector = S el e ct Fr o mM od e l ( SGDClassifier ( random_state =0) , threshold = ’ mean ’)
6 selector . fit (X , y )
7 selector . estimator_ . coef_

Résultat :

array([[ 8.64029104, 27.2851296 , -40.01819009, -17.73533424],

[ -5.48888269, -58.79616709, 22.88584985, -54.14457159],
[-81.28026953, -75.17372078, 130.76437145, 131.39608339]])
Les caractéristiques sélectionnées :

1 np . array ( iris . feature_names ) [ selector . get_support () ]

Résultat :
array([’petal length (cm)’, ’petal width (cm)’], dtype=’<U17’)

SelectFromModel utilise les coefficients du modèle SGDClassifier pour déterminer l’importance

des caractéristiques. Avec threshold=’mean’, les caractéristiques dont l’importance (basée sur la
valeur absolue des coefficients) est supérieure à la moyenne sont retenues.
Les coefficients montrent le poids attribué à chaque caractéristique pour chaque classe. Dans ce
cas, les caractéristiques petal length (cm) et petal width (cm) ont été sélectionnées car leurs
coefficients (en valeur absolue) étaient plus importants.
Cette approche est particulièrement utile car elle est basée directement sur le modèle que vous pré-
voyez d’utiliser, garantissant ainsi que les caractéristiques sélectionnées sont réellement pertinentes
pour ce modèle spécifique.

5.23 Apprentissage Non-Supervisé

5.23.1 K-Means Clustering

Explication

K-Means est un algorithme de clustering qui cherche à partitionner les données en K groupes
distincts en minimisant la variance intra-cluster.

1 import numpy as np
2 import matplotlib . pyplot as plt
3 from sklearn . datasets import make_blobs
4 from sklearn . cluster import KMeans
5
6 # G n r a t i o n de d o n n e s
7 X , y = make_blobs ( n_samples =100 , centers =3 , cluster_std =0.4 , random_state =0)
8 plt . scatter ( X [: ,0] , X [: ,1])

BDCC-S3-2024-2025 117 Mohamed Ouazze

5 MACHINE LEARNING

Figure 98 – Données générées avec make_blobs

Explication

1 model = KMeans ( n_clusters =3)
2 model . fit ( X )
3 model . predict ( X )
4 plt . scatter ( X [: ,0] , X [: ,1] , c = model . predict ( X ) )
5 plt . scatter ( model . c l u s t e r _ c e n t e r s _ [: ,0] , model . c l u s t e r _ c e n t e r s _ [: ,1] , c = ’r ’)
6 model . score ( X )

Figure 99 – Clusters identifiés par K-Means (points rouges = centres des clusters)

BDCC-S3-2024-2025 118 Mohamed Ouazze

5 MACHINE LEARNING

5.23.2 Elbow Method

Explication

La méthode du coude (Elbow Method) permet de déterminer le nombre optimal de clusters en

examinant comment l’inertie (somme des carrés des distances) diminue en fonction du nombre de
clusters.

1 inertia = []
2 K_range = range (1 , 20)
3 for k in K_range :
4 model = KMeans ( n_clusters = k ) . fit ( X )
5 inertia . append ( model . inertia_ )
6 plt . plot ( K_range , inertia )
7 plt . xlabel ( ’ nombre de clusters ’)
8 plt . ylabel ( ’ Cout du modele ( Inertia ) ’)

Figure 100 – Graphique de la méthode du coude montrant l’inertie en fonction du nombre de clusters

Explication

Le coude dans le graphique indique généralement le nombre optimal de clusters, où ajouter plus
de clusters n’améliore pas significativement la qualité du clustering.

5.23.3 Détection d’anomalies avec Isolation Forest

Explication

Isolation Forest est un algorithme de détection d’anomalies basé sur l’isolation des observations
aberrantes par rapport au reste des données.

1 from sklearn . ensemble import I so l at io n Fo re s t
2
3 X , y = make_blobs ( n_samples =50 , centers =1 , cluster_std =0.1 , random_state =0)
4 X [ -1 ,:] = np . array ([2.25 , 5])
5 plt . scatter ( X [: ,0] , X [: , 1])

BDCC-S3-2024-2025 119 Mohamed Ouazze

5 MACHINE LEARNING

Figure 101 – Données avec une anomalie visible

Explication

1 model = Iso l at i on Fo r es t ( contamination =0.01)
2 model . fit ( X )
3 plt . scatter ( X [: ,0] , X [: , 1] , c = model . predict ( X ) )

Figure 102 – Résultat de la détection d’anomalies par Isolation Forest

Explication

Le paramètre contamination représente la proportion attendue d’observations anomales dans le

jeu de données. Les points identifiés comme anomalies sont codés différemment (généralement par
-1).

BDCC-S3-2024-2025 120 Mohamed Ouazze

5 MACHINE LEARNING

5.23.4 Application : Détection d’anomalies sur Digits

Explication

Application de l’Isolation Forest sur le jeu de données des chiffres manuscrits pour identifier les
chiffres atypiques.

1 from sklearn . datasets import load_digits
2 digits = load_digits ()
3 images = digits . images
4 X = digits . data
5 y = digits . target
6 plt . imshow ( images [0])

Figure 103 – Exemple d’un chiffre manuscrit du jeu de données

Explication

1 model = I so l at i on Fo r es t ( random_state =0 , contamination =0.02)
2 model . fit ( X )
3 outliers = model . predict ( X ) == -1
4
5 plt . figure ( figsize =(12 , 3) )
6 for i in range (10) :
7 plt . subplot (1 , 10 , i +1)
8 plt . imshow ( images [ outliers ][ i ])
9 plt . title ( y [ outliers ][ i ])

Explication

L’Isolation Forest identifie les chiffres manuscrits qui sont les plus difficiles à reconnaître ou qui
présentent des caractéristiques atypiques par rapport aux autres échantillons de la même classe.

BDCC-S3-2024-2025 121 Mohamed Ouazze

5 MACHINE LEARNING

Figure 104 – Les 10 premières anomalies détectées dans le jeu de données Digits

5.23.5 PCA : Réduction de dimension

Explication

L’Analyse en Composantes Principales (PCA) est une technique de réduction de dimensionnalité

qui projette les données dans un espace de dimension inférieure tout en préservant au maximum
la variance.

5.23.5.1 Visualisation 2D
1 from sklearn . decomposition import PCA
2
3 model = PCA ( n_components =2)
4 model . fit ( X )

Résultat :
PCA(copy=True, iterated_power=’auto’, n_components=2, random_state=None,
svd_solver=’auto’, tol=0.0, whiten=False)

1 x_pca = model . transform ( X )
2 plt . scatter ( x_pca [: ,0] , x_pca [: ,1] , c = y )

Figure 105 – Projection des données Digits sur les deux premières composantes principales

BDCC-S3-2024-2025 122 Mohamed Ouazze

5 MACHINE LEARNING

Explication

1 plt . figure ()
2 plt . xlim ( -30 , 30)
3 plt . ylim ( -30 , 30)
4
5 for i in range (100) :
6 plt . text ( x_pca [i ,0] , x_pca [i ,1] , str ( y [ i ]) )

Figure 106 – Affichage des étiquettes des 100 premiers points dans l’espace PCA

Explication

Compression de données

1 n_dims = X . shape [1]
2 model = PCA ( n_components = n_dims )
3 model . fit ( X )
4
5 variances = model . e x p l a i n e d _ v a r i a n c e _ r a t i o _
6
7 meilleur_dims = np . argmax ( np . cumsum ( variances ) > 0.90)
8
9 plt . bar ( range ( n_dims ) , np . cumsum ( variances ) )
10 plt . hlines (0.90 , 0 , meilleur_dims , colors = ’r ’)
11 plt . vlines ( meilleur_dims , 0 , 0.90 , colors = ’r ’)

Figure 107 – Variance cumulée expliquée en fonction du nombre de composantes

BDCC-S3-2024-2025 123 Mohamed Ouazze

5 MACHINE LEARNING

Explication

1 model = PCA ( n_components =0.99)
2 model . fit ( X )

Résultat :
PCA(copy=True, iterated_power=’auto’, n_components=0.99, random_state=None,
svd_solver=’auto’, tol=0.0, whiten=False)

1 X_compress = model . fit_transform ( X )
2 X_decompress = model . i n v e r s e _ t r a n s f o r m ( X_compress )
3
4 plt . subplot (1 , 2 , 1)
5 plt . imshow ( X [0 ,:]. reshape ((8 ,8) ) , cmap = ’ gray ’)
6 plt . title ( ’ originel ’)
7 plt . subplot (1 , 2 , 2)
8 plt . imshow ( X_decompress [0 ,:]. reshape ((8 ,8) ) , cmap = ’ gray ’)
9 plt . title ( ’ C o m p r e s s ’)

Figure 108 – Comparaison entre une image originale et sa version compressée/décompressée par PCA

Explication

La PCA est utilisée ici pour deux objectifs principaux :

— Visualisation : projeter les données 64-dimensionnelles sur un plan 2D pour observer la
structure des données
— Compression : réduire la dimension tout en conservant un certain pourcentage de la variance
totale (ici 99%)
En fixant n_components=0.99, on demande à PCA de sélectionner automatiquement le nombre de
composantes nécessaires pour expliquer 99% de la variance totale, ce qui permet une compression
efficace avec une perte d’information minimale.

BDCC-S3-2024-2025 124 Mohamed Ouazze

5 MACHINE LEARNING

5.24 Ensemble Learning

Explication

L’apprentissage d’ensemble (Ensemble Learning) combine plusieurs modèles pour améliorer les
performances de prédiction. Ces techniques permettent de réduire la variance, le biais et d’amé-
liorer la généralisation des modèles.

1 import numpy as np
2 import matplotlib . pyplot as plt
3 from sklearn . datasets import make_moons
4 from sklearn . m od el _ se le c ti on import t r a i n _ t e s t _ s p l i t
5 from matplotlib . colors import List edColo rmap
6
7 def p l o t _ d e c i s i o n _ b o u n d a r y ( clf , X , y , axes =[ -1.5 , 2.45 , -1 , 1.5] , alpha =0.5 ,
contour = True ) :
8 h = .02
9 x_min , x_max = X [: , 0]. min () - .5 , X [: , 0]. max () + .5
10 y_min , y_max = X [: , 1]. min () - .5 , X [: , 1]. max () + .5
11 xx , yy = np . meshgrid ( np . arange ( x_min , x_max , h ) ,
12 np . arange ( y_min , y_max , h ) )
13
14 Z = clf . predict_proba ( np . c_ [ xx . ravel () , yy . ravel () ]) [: , 1]
15 Z = Z . reshape ( xx . shape )
16 plt . contourf ( xx , yy , Z , alpha =.5)
17
18 plt . scatter ( X [: ,0] , X [: ,1] , c =y , alpha =0.8 , edgecolors = ’k ’)
19
20 X , y = make_moons ( n_samples =500 , noise =0.3 , random_state =0)
21 plt . scatter ( X [: ,0] , X [: ,1] , c =y , alpha =0.8)
22 X_train , X_test , y_train , y_test = t r a i n _ t e s t _ s p l i t (X , y , test_size =0.3 ,
random_state =0)

Le jeu de données make_moons génère deux classes en forme de croissants de lune. Le paramètre
noise=0.3 ajoute du bruit pour rendre la classification plus difficile, créant ainsi un problème
non-linéaire qui permet de bien comparer les différentes techniques d’ensemble.

Figure 109 – Jeu de données make_moons avec bruit

BDCC-S3-2024-2025 125 Mohamed Ouazze

5 MACHINE LEARNING

5.24.1 Voting Classifier

Explication

Le Voting Classifier combine les prédictions de plusieurs modèles différents selon une règle de vote
majoritaire (vote dur) ou une moyenne des probabilités prédites (vote souple).

1 from sklearn . linear_model import SGDClassifier
2 from sklearn . tree import D e c i s i o n T r e e C l a s s i f i e r
3 from sklearn . neighbors import K N e i g h b o r s C l a s s i f i e r
4 from sklearn . ensemble import V o t i n g C l a s s i f i e r
5
6 model_1 = SGDClassifier ( random_state =0)
7 model_2 = D e c i s i o n T r e e C l a s s i f i e r ( random_state =0)
8 model_3 = K N e i g h b o r s C l a s s i f i e r ( n_neighbors =2)
9 model_4 = V o t i n g C l a s s i f i e r ([( ’ SGD ’ , model_1 ) ,
10 ( ’ Tree ’ , model_2 ) ,
11 ( ’ KNN ’ , model_3 ) ] ,
12 voting = ’ hard ’)
13
14 for model in ( model_1 , model_2 , model_3 , model_4 ) :
15 model . fit ( X_train , y_train )
16 print ( model . __class__ . __name__ , model . score ( X_test , y_test ) )

SGDClassifier 0.8266666666666667
DecisionTreeClassifier 0.8533333333333334
KNeighborsClassifier 0.8066666666666666
VotingClassifier 0.8666666666666667

Le VotingClassifier combine trois classifieurs différents (SGD, Decision Tree, et KNN) et utilise
un vote majoritaire (voting=’hard’) pour faire ses prédictions. On observe souvent que l’ensemble
offre des performances supérieures ou égales au meilleur classifieur individuel, ce qui démontre
l’avantage de combiner plusieurs modèles.

BDCC-S3-2024-2025 126 Mohamed Ouazze

5 MACHINE LEARNING

5.24.2 Bagging

Explication

Le Bagging (Bootstrap Aggregating) entraîne plusieurs instances du même modèle sur différents
sous-ensembles des données d’entraînement générés par échantillonnage avec remise.

1 from sklearn . ensemble import BaggingClassifier , R a n d o m F o r e s t C l a s s i f i e r
2
3 model = B a g g i n g C l a s s i f i e r ( ba se_est imator = K N e i g h b o r s C l a s s i f i e r () ,
4 n_estimators =100)
5 model . fit ( X_train , y_train )
6 model . score ( X_test , y_test )

0.8733333333333333

1 model = R a n d o m F o r e s t C l a s s i f i e r ( n_estimators =100)
2 model . fit ( X_train , y_train )
3 model . score ( X_test , y_test )

0.8866666666666667

1 p l o t _ d e c i s i o n _ b o u n d a r y ( model , X_train , y_train )

Le BaggingClassifier applique le principe du bagging avec un classifieur KNN comme estimateur

de base. Le RandomForestClassifier est un cas particulier de bagging qui utilise des arbres de
décision comme estimateurs de base et introduit une sélection aléatoire de caractéristiques à chaque
nœud de l’arbre.
On observe que le Random Forest offre les meilleures performances, car il combine efficacement
la diversité des sous-ensembles d’entraînement avec la diversité des caractéristiques utilisées pour
chaque arbre.

Figure 110 – Frontière de décision d’un Random Forest

BDCC-S3-2024-2025 127 Mohamed Ouazze

5 MACHINE LEARNING

5.24.3 Boosting

Explication

Le Boosting entraîne séquentiellement une série de modèles faibles, chaque nouveau modèle se
concentrant sur les erreurs des modèles précédents.

1 from sklearn . ensemble import AdaBoostClassifier , G r a d i e n t B o o s t i n g C l a s s i f i e r
2
3 model = A d a B o o s t C l a s s i f i e r ( n_estimators =100)
4 model . fit ( X_train , y_train )
5 model . score ( X_test , y_test )

0.8666666666666667

1 p l o t _ d e c i s i o n _ b o u n d a r y ( model , X_train , y_train )

AdaBoostClassifier est une implémentation de l’algorithme AdaBoost (Adaptive Boosting). Il

ajuste les poids des échantillons d’entraînement après chaque itération, donnant plus d’importance
aux exemples mal classifiés. Cela permet au modèle de se concentrer progressivement sur les cas
les plus difficiles.
La frontière de décision montre comment AdaBoost crée une frontière complexe qui s’adapte bien
aux données en forme de croissants de lune.

Figure 111 – Frontière de décision d’un AdaBoost

BDCC-S3-2024-2025 128 Mohamed Ouazze

5 MACHINE LEARNING

5.24.4 Stacking

Explication

Le Stacking combine plusieurs modèles en entraînant un méta-modèle qui apprend à intégrer les
prédictions des modèles de base.

1 from sklearn . ensemble import S t a c k i n g C l a s s i f i e r
2
3 model = S t a c k i n g C l a s s i f i e r ([( ’ SGD ’ , model_1 ) ,
4 ( ’ Tree ’ , model_2 ) ,
5 ( ’ KNN ’ , model_3 ) ] ,
6 f in al _ es ti m at o r = K N e i g h b o r s C l a s s i f i e r () )
7 model . fit ( X_train , y_train )
8 model . score ( X_test , y_test )

0.8733333333333333

1 p l o t _ d e c i s i o n _ b o u n d a r y ( model , X_train , y_train )

StackingClassifier combine les trois classifieurs précédents (SGD, Decision Tree, et KNN) en
utilisant un classifieur KNN comme méta-modèle. Contrairement au VotingClassifier qui utilise
un vote simple, le stacking apprend à combiner les prédictions des modèles de base de manière
optimale.
La frontière de décision montre comment le modèle de stacking peut capturer des structures
complexes dans les données en tirant parti des forces de chaque classifieur de base.

Figure 112 – Frontière de décision d’un modèle de Stacking

BDCC-S3-2024-2025 129 Mohamed Ouazze

6 CONCLUSION

6 Conclusion
Explication

Dans ce cours, nous avons exploré les principaux aspects de l’apprentissage automatique, en cou-
vrant à la fois des techniques supervisées et non-supervisées. Nous avons étudié :
— Les algorithmes de classification et de régression
— Les méthodes de sélection de caractéristiques (RFE, SelectFromModel)
— Les techniques de clustering (K-Means)
— La détection d’anomalies (Isolation Forest)
— La réduction de dimension (PCA)
— Les méthodes d’ensemble (Voting, Bagging, Boosting, Stacking)
Ces techniques constituent la base de l’apprentissage automatique classique. Elles offrent une
grande variété d’outils pour aborder différents types de problèmes et de données.
Dans le prochain cours, nous aborderons le deep learning, qui étend ces concepts avec des archi-
tectures de réseaux de neurones plus complexes capables de modéliser des fonctions hautement
non-linéaires et de traiter des données structurées comme les images, le texte et les séries tempo-
relles.
Le deep learning nous permettra d’explorer :
— Les réseaux de neurones multicouches (MLP)
— Les réseaux de neurones convolutifs (CNN) pour le traitement d’images
— Les réseaux récurrents (RNN, LSTM, GRU) pour les séquences
— Les techniques de transfer learning et d’apprentissage par renforcement
Les techniques apprises dans ce cours resteront pertinentes même dans le contexte du deep learning,
car elles offrent souvent des solutions plus interprétables, plus rapides à entraîner et parfois plus
performantes sur des problèmes où les données sont limitées ou la structure est simple.

Félicitations ! Vous avez désormais terminé ce cours complet sur l’apprentissage au-
tomatique classique. Vous êtes maintenant capable d’écrire des programmes efficaces et
performants en utilisant les principales techniques du domaine. Ce n’est qu’un début
dans votre parcours en intelligence artificielle, mais vous disposez déjà des fondamentaux
essentiels pour résoudre de nombreux problèmes concrets.
Si vous avez des questions ou besoin de précisions sur les concepts abordés, n’hésitez pas
à me contacter sur LinkedIn : Mohamed Ouazze.
Vos retours sont précieux et contribueront à l’amélioration continue de ce cours.

À bientôt pour notre prochain cours sur le deep learning !

BDCC-S3-2024-2025 130 Mohamed Ouazze