%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %%
> [!nav]
> ↩ [[Analyse et Données/Data Science/Data Mining/Data Mining|Accueil · Data Mining]]
>
> | [[Analyse et Données/Data Science/Data Mining/Cours 1 - Data mining avec python\|← Cours 1 - Data mining avec python]] | [[Analyse et Données/Data Science/Data Mining/Cours 3 - Data mining avec python\|Cours 3 - Data mining avec python →]] |
> |:---|---:|
%% nav-fin %%
# Visuels avec Matplotlib pour le Data Mining
Bienvenue dans ce chapitre essentiel de votre parcours en Data Science. Après avoir maîtrisé les techniques de pré-traitement des données, il est temps d'apprendre à "voir" vos données. La visualisation est une compétence fondamentale en Data Mining, car elle permet de transformer des chiffres bruts en informations compréhensibles et exploitables. Matplotlib est la bibliothèque de référence en Python pour créer des graphiques statiques de haute qualité.
# Introduction : L'Importance de la Visualisation en Data Mining
Le Data Mining ne se limite pas à l'application d'algorithmes complexes. Une étape cruciale, souvent sous-estimée, est l'Exploration des Données (EDA - *Exploratory Data Analysis*). La visualisation est le pilier de l'EDA, offrant une fenêtre sur la structure, les patterns, les anomalies et les relations cachées au sein de vos jeux de données.
> [!definition] Data Mining
> Le Data Mining est le processus de découverte de patterns, de tendances et d'informations utiles à partir de grands ensembles de données. Il combine des méthodes issues de la statistique, de l'intelligence artificielle et de l'apprentissage automatique.
> [!note] Pourquoi visualiser ?
> 1. **Comprendre la distribution des données** : Identifier les plages de valeurs, les concentrations, les asymétries.
> 2. **Détecter les valeurs aberrantes (outliers)** : Repérer les points de données qui s'écartent significativement de la norme.
> 3. **Identifier les relations entre variables** : Mettre en évidence les corrélations, les dépendances.
> 4. **Valider les hypothèses** : Confirmer ou infirmer des intuitions sur les données.
> 5. **Communiquer les résultats** : Présenter les découvertes de manière claire et percutante à des non-experts.
> [!tip] Lien avec les pré-requis
> Vous avez appris à nettoyer, transformer et structurer vos données. La visualisation est la suite logique pour **vérifier l'efficacité de ces transformations** et **préparer le terrain pour la modélisation**. Par exemple, visualiser la distribution d'une variable après une transformation logarithmique peut confirmer qu'elle est devenue plus "normale".
# Matplotlib : Le Couteau Suisse de la Visualisation
Matplotlib est une bibliothèque complète pour créer des visualisations statiques, animées et interactives en Python. Bien qu'il existe d'autres bibliothèques (comme Seaborn, Plotly, Bokeh) qui s'appuient parfois sur Matplotlib ou offrent des fonctionnalités spécifiques, Matplotlib reste le fondement et offre un contrôle granulaire sur chaque aspect de vos graphiques.
## Les Bases : `pyplot`, Figure et Axes
Le module `matplotlib.pyplot` est une interface basée sur des fonctions qui fournit un moyen simple et rapide de créer des graphiques. C'est souvent la première approche pour les débutants.
> [!definition] Figure et Axes
> En Matplotlib, une **Figure** est le conteneur de niveau supérieur pour tous les éléments d'un graphique (titres, étiquettes, tracés). Un **Axes** (ou sous-graphique) est la zone où les données sont réellement tracées. Une Figure peut contenir un ou plusieurs Axes.
```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Création d'une Figure et d'un ensemble d'Axes
fig, ax = plt.subplots(figsize=(8, 6)) # figsize=(largeur, hauteur) en pouces
# Exemple simple de tracé
x = np.linspace(0, 10, 100)
y = np.sin(x)
ax.plot(x, y, label='sin(x)', color='blue', linestyle='--')
# Ajout de titres et étiquettes
ax.set_title('Exemple de Tracé Sinusoïdal')
ax.set_xlabel('Axe des X')
ax.set_ylabel('Axe des Y')
ax.legend() # Affiche la légende si des labels sont définis
plt.show() # Affiche le graphique
```
> [!note] `plt.show()`
> `plt.show()` est essentiel pour afficher le graphique dans la plupart des environnements. Dans un environnement interactif comme Jupyter Notebook ou IPython, les graphiques peuvent s'afficher automatiquement sans `plt.show()` si le mode `%matplotlib inline` est activé.
## Types de Tracés Fondamentaux
### Tracé Linéaire (`plot`)
Idéal pour visualiser l'évolution d'une variable continue, notamment les séries temporelles.
```python
# Exemple de série temporelle
dates = pd.to_datetime(pd.date_range(start='2023-01-01', periods=50, freq='D'))
valeurs = np.random.randn(50).cumsum() + 100
fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(dates, valeurs, marker='o', linestyle='-', color='green', label='Valeurs Quotidiennes')
ax.set_title('Évolution de la Valeur au Fil du Temps')
ax.set_xlabel('Date')
ax.set_ylabel('Valeur')
ax.legend()
ax.grid(True) # Ajoute une grille
plt.xticks(rotation=45) # Rotation des étiquettes de l'axe X pour une meilleure lisibilité
plt.tight_layout() # Ajuste automatiquement les paramètres du subplot pour donner de l'espace
plt.show()
```
### Nuage de Points (`scatter`)
Utilisé pour visualiser la relation entre deux variables numériques. Chaque point représente une observation.
```python
# Données fictives pour un nuage de points
np.random.seed(42)
taille = np.random.normal(170, 10, 100) # Taille en cm
poids = taille * 0.6 + np.random.normal(0, 5, 100) # Poids en kg
fig, ax = plt.subplots(figsize=(8, 6))
ax.scatter(taille, poids, alpha=0.7, color='purple', s=50) # alpha pour la transparence, s pour la taille des points
ax.set_title('Relation entre Taille et Poids')
ax.set_xlabel('Taille (cm)')
ax.set_ylabel('Poids (kg)')
plt.show()
```
> [!note] Corrélation
> Un nuage de points permet de visualiser rapidement si deux variables $X$ et $Y$ sont positivement corrélées (les points montent de gauche à droite), négativement corrélées (les points descendent) ou non corrélées (les points sont dispersés sans tendance claire). Le coefficient de corrélation de Pearson $r$ est souvent utilisé pour quantifier cette relation linéaire :
> $ r = \frac{\sum_{i=1}^n (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum_{i=1}^n (x_i - \bar{x})^2 \sum_{i=1}^n (y_i - \bar{y})^2}} $
> où $\bar{x}$ et $\bar{y}$ sont les moyennes de $X$ et $Y$.
# Visualisations pour l'Analyse Univariée
L'analyse univariée consiste à examiner une seule variable à la fois. Elle est fondamentale pour comprendre la distribution et les caractéristiques de chaque feature de votre dataset.
## Histogrammes (`hist`)
Les histogrammes montrent la distribution de fréquence d'une variable numérique. Ils divisent la plage de valeurs en "bins" (intervalles) et comptent le nombre d'observations dans chaque bin.
```python
# Données d'exemple : âges d'un groupe de personnes
ages = np.random.randint(18, 65, 200)
fig, ax = plt.subplots(figsize=(9, 6))
ax.hist(ages, bins=10, color='skyblue', edgecolor='black', alpha=0.8) # bins: nombre de barres
ax.set_title('Distribution des Âges')
ax.set_xlabel('Âge')
ax.set_ylabel('Fréquence')
plt.show()
```
> [!tip] Choisir le nombre de `bins`
> Le nombre de `bins` peut significativement affecter l'apparence de l'histogramme. Trop peu de bins masquent les détails, trop de bins peuvent rendre le graphique bruité. Il n'y a pas de règle unique, mais des méthodes comme la règle de Sturges ($k = 1 + \log_2 N$) peuvent donner une bonne estimation initiale.
> Pour $N$ observations, le nombre de bins $k$ est environ $k = 1 + 3.322 \log_{10} N$.
## Diagrammes en Boîte (`boxplot`)
Les boîtes à moustaches sont excellentes pour visualiser la distribution, la médiane, les quartiles et les valeurs aberrantes d'une variable numérique.
```python
# Données d'exemple : scores à un examen pour deux groupes
scores_groupe_A = np.random.normal(75, 10, 100)
scores_groupe_B = np.random.normal(70, 15, 100)
fig, ax = plt.subplots(figsize=(8, 6))
ax.boxplot([scores_groupe_A, scores_groupe_B], labels=['Groupe A', 'Groupe B'], patch_artist=True) # patch_artist pour colorer les boîtes
ax.set_title('Comparaison des Scores par Groupe')
ax.set_ylabel('Score')
ax.grid(axis='y', linestyle='--') # Grille sur l'axe Y
plt.show()
```
> [!definition] Éléments d'une Boîte à Moustaches
> * **Ligne centrale** : Médiane (50ème percentile).
> * **Boîte** : S'étend du premier quartile (Q1, 25ème percentile) au troisième quartile (Q3, 75ème percentile). La hauteur de la boîte est l'écart interquartile (IQR = Q3 - Q1).
> * **Moustaches** : S'étendent jusqu'à $Q1 - 1.5 \times IQR$ et $Q3 + 1.5 \times IQR$, ou jusqu'aux valeurs minimales/maximales si elles sont à l'intérieur de ces limites.
> * **Points individuels** : Valeurs aberrantes (outliers), c'est-à-dire les points en dehors des moustaches.
> [!theorem] Détection des Outliers avec l'IQR
> Une observation est souvent considérée comme une valeur aberrante si elle est inférieure à $Q1 - 1.5 \times IQR$ ou supérieure à $Q3 + 1.5 \times IQR$.
# Visualisations pour l'Analyse Bivariée et Multivariée
L'analyse bivariée examine la relation entre deux variables, tandis que l'analyse multivariée explore les relations entre trois variables ou plus.
## Nuages de Points Colorés / Taille (`scatter` avec une 3ème variable)
Pour explorer une troisième variable, on peut utiliser la couleur ou la taille des points dans un nuage de points.
```python
# Données fictives : Taille, Poids, et Âge pour 100 personnes
np.random.seed(43)
taille = np.random.normal(170, 10, 100)
poids = taille * 0.6 + np.random.normal(0, 5, 100)
age = np.random.randint(18, 70, 100)
sexe = np.random.choice(['Homme', 'Femme'], 100)
# Création d'un DataFrame pour faciliter la manipulation
df = pd.DataFrame({'taille': taille, 'poids': poids, 'age': age, 'sexe': sexe})
fig, ax = plt.subplots(figsize=(10, 7))
# Utilisation de la couleur pour la variable 'sexe'
scatter = ax.scatter(df['taille'], df['poids'],
c=df['age'], # La couleur représente l'âge
cmap='viridis', # Palette de couleurs
s=df['age']*2, # La taille des points représente aussi l'âge (mis à l'échelle)
alpha=0.7,
label='Relation Taille-Poids par Âge')
ax.set_title('Relation Taille-Poids, colorée et dimensionnée par l\'âge')
ax.set_xlabel('Taille (cm)')
ax.set_ylabel('Poids (kg)')
# Ajout d'une barre de couleur pour l'âge
cbar = fig.colorbar(scatter)
cbar.set_label('Âge')
plt.show()
```
## Diagrammes à Barres (`bar`)
Les diagrammes à barres sont utiles pour comparer des catégories ou pour montrer la relation entre une variable catégorielle et une variable numérique.
```python
# Données d'exemple : ventes moyennes par région
regions = ['Nord', 'Sud', 'Est', 'Ouest', 'Centre']
ventes = [150, 210, 180, 120, 195]
fig, ax = plt.subplots(figsize=(9, 6))
ax.bar(regions, ventes, color=['blue', 'green', 'red', 'purple', 'orange'])
ax.set_title('Ventes Moyennes par Région')
ax.set_xlabel('Région')
ax.set_ylabel('Ventes Moyennes (€)')
plt.show()
```
> [!note] Diagrammes à barres empilées ou groupées
> Pour comparer plusieurs séries de données catégorielles, vous pouvez utiliser des barres empilées (`bottom` argument de `ax.bar`) ou groupées (en ajustant les positions des barres).
## Heatmaps (Cartes de Chaleur)
Les heatmaps sont excellentes pour visualiser des matrices, comme les matrices de corrélation, où l'intensité de la couleur représente la valeur.
```python
# Création d'un DataFrame avec des données aléatoires pour la corrélation
data = {
'VarA': np.random.rand(50),
'VarB': np.random.rand(50) * 2,
'VarC': np.random.rand(50) + np.random.rand(50),
'VarD': np.random.rand(50) * 3 - np.random.rand(50)
}
df_corr = pd.DataFrame(data)
# Calcul de la matrice de corrélation
correlation_matrix = df_corr.corr()
fig, ax = plt.subplots(figsize=(8, 7))
cax = ax.imshow(correlation_matrix, cmap='coolwarm', interpolation='nearest') # interpolation pour l'affichage
ax.set_title('Matrice de Corrélation des Variables')
# Ajout des étiquettes des axes
ax.set_xticks(np.arange(len(correlation_matrix.columns)))
ax.set_yticks(np.arange(len(correlation_matrix.columns)))
ax.set_xticklabels(correlation_matrix.columns, rotation=45, ha='right')
ax.set_yticklabels(correlation_matrix.columns)
# Ajout des valeurs de corrélation sur la heatmap
for i in range(len(correlation_matrix.columns)):
for j in range(len(correlation_matrix.columns)):
text = ax.text(j, i, f'{correlation_matrix.iloc[i, j]:.2f}',
ha='center', va='center', color='black', fontsize=9)
fig.colorbar(cax, label='Coefficient de Corrélation')
plt.tight_layout()
plt.show()
```
> [!warning] Interprétation des Heatmaps de Corrélation
> * Les valeurs proches de +1 indiquent une forte corrélation positive.
> * Les valeurs proches de -1 indiquent une forte corrélation négative.
> * Les valeurs proches de 0 indiquent une faible ou aucune corrélation linéaire.
> * La diagonale est toujours 1 (corrélation d'une variable avec elle-même).
> * La matrice est symétrique.
> Une forte corrélation n'implique pas une relation de causalité !
## Subplots : Combiner Plusieurs Graphiques
Les subplots permettent d'afficher plusieurs graphiques dans une même Figure, ce qui est idéal pour comparer différentes distributions ou relations côte à côte.
```python
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(12, 5)) # 1 ligne, 2 colonnes
# Premier subplot : Histogramme
axes[0].hist(df['taille'], bins=15, color='lightcoral', edgecolor='black')
axes[0].set_title('Distribution des Tailles')
axes[0].set_xlabel('Taille (cm)')
axes[0].set_ylabel('Fréquence')
# Deuxième subplot : Boxplot
axes[1].boxplot([df['poids'][df['sexe'] == 'Homme'], df['poids'][df['sexe'] == 'Femme']],
labels=['Hommes', 'Femmes'], patch_artist=True,
boxprops=dict(facecolor='lightblue'))
axes[1].set_title('Poids par Sexe')
axes[1].set_ylabel('Poids (kg)')
plt.tight_layout() # Ajuste les subplots pour éviter le chevauchement
plt.show()
```
# Personnalisation et Améliorations
Matplotlib offre un contrôle étendu sur l'apparence de vos graphiques.
## Titres, Labels et Légendes
```python
fig, ax = plt.subplots()
ax.plot(x, y, label='Courbe Sinusoïdale')
ax.set_title('Mon Super Graphique', fontsize=16, color='darkblue')
ax.set_xlabel('Temps (s)', fontsize=12)
ax.set_ylabel('Amplitude', fontsize=12)
ax.legend(loc='upper right', frameon=True, shadow=True, fancybox=True) # Personnalisation de la légende
plt.show()
```
## Couleurs, Marqueurs et Styles de Ligne
```python
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, np.sin(x), 'r-o', label='sin(x)') # 'r-o' : rouge, ligne continue, marqueurs cercles
ax.plot(x, np.cos(x), color='green', linestyle=':', marker='x', markersize=5, label='cos(x)')
ax.legend()
plt.show()
```
## Annotations et Texte
Ajouter du texte ou des flèches pour mettre en évidence des points spécifiques.
```python
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('Point Spécifique')
ax.annotate('Maximum local', xy=(np.pi/2, 1), xytext=(np.pi/2 + 2, 0.5),
arrowprops=dict(facecolor='black', shrink=0.05),
fontsize=10, color='red')
plt.show()
```
## Sauvegarde des Graphiques
```python
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('Graphique à Sauvegarder')
plt.savefig('mon_graphique.png', dpi=300, bbox_inches='tight') # dpi pour la résolution, bbox_inches pour éviter les marges blanches
# Autres formats : .pdf, .svg, .jpg
plt.close(fig) # Ferme la figure pour libérer la mémoire si non affichée
```
# Intégration dans le Workflow de Data Mining
La visualisation n'est pas une étape isolée, elle est intégrée à chaque phase du processus de Data Mining.
## Exploration des Données (EDA)
C'est ici que Matplotlib brille. Avant toute modélisation, visualisez :
* Les distributions de toutes les variables (histogrammes, boxplots).
* Les relations entre les variables (nuages de points, heatmaps de corrélation).
* La présence de valeurs manquantes (peut être visualisé, par exemple, avec un heatmap de `df.isnull()`).
* Les valeurs aberrantes.
## Ingénierie des Caractéristiques (Feature Engineering)
Après avoir créé de nouvelles caractéristiques ou transformé des existantes, utilisez la visualisation pour :
* Vérifier l'impact d'une transformation (ex: distribution avant/après log).
* Comprendre la nouvelle caractéristique (sa distribution, sa relation avec la cible).
## Préparation à l'Apprentissage Supervisé
Bien que la visualisation des modèles eux-mêmes relève du prochain chapitre, Matplotlib est essentiel pour :
* **Visualiser la variable cible** : Sa distribution, son équilibre dans le cas de classification.
* **Identifier les caractéristiques importantes** : Les visualisations peuvent suggérer quelles caractéristiques sont les plus discriminantes pour prédire la cible.
* **Comprendre les groupes de données** : Si vous avez appliqué des techniques de clustering (apprentissage non supervisé), Matplotlib vous aidera à visualiser ces clusters.
> [!example] Préparation à l'Apprentissage Supervisé
> Supposons que vous ayez une variable cible binaire (`0` ou `1`). Un diagramme à barres montrant le compte de chaque classe est crucial pour vérifier l'équilibre des classes.
>
> ```python
> # Données fictives : variable cible déséquilibrée
> target_variable = np.random.choice([0, 1], size=200, p=[0.8, 0.2])
>
> fig, ax = plt.subplots(figsize=(6, 4))
> pd.Series(target_variable).value_counts().plot(kind='bar', ax=ax, color=['red', 'green'])
> ax.set_title('Distribution de la Variable Cible')
> ax.set_xlabel('Classe')
> ax.set_ylabel('Nombre d\'Observations')
> plt.xticks(rotation=0)
> plt.show()
> ```
> Ce graphique montre un déséquilibre de classes, ce qui est une information vitale pour le choix et l'entraînement de votre modèle d'apprentissage supervisé.
# Bonnes Pratiques et Pièges à Éviter
> [!tip] Bonnes Pratiques
> 1. **Clarté et Simplicité** : Un graphique doit être facile à comprendre. Évitez l'encombrement.
> 2. **Titres et Étiquettes Explicites** : Chaque graphique doit avoir un titre clair et des étiquettes d'axes informatives.
> 3. **Légendes** : Utilisez des légendes si plusieurs éléments sont tracés.
> 4. **Choix du Bon Type de Graphique** :
> * Distribution d'une variable numérique : histogramme, boxplot.
> * Relation numérique-numérique : nuage de points.
> * Relation catégorielle-numérique : diagramme à barres, boxplot (par catégorie).
> * Série temporelle : tracé linéaire.
> 5. **Couleurs et Accessibilité** : Utilisez des palettes de couleurs perceptuellement uniformes et tenez compte du daltonisme.
> 6. **Grilles** : Utilisez-les avec parcimonie pour la lisibilité.
> 7. **`plt.tight_layout()`** : Toujours utiliser pour éviter le chevauchement des éléments.
> [!warning] Pièges à Éviter
> 8. **Axes Mal Échelonnés** : Des échelles tronquées peuvent induire en erreur sur l'ampleur des différences.
> 9. **Graphiques en 3D Inutiles** : Souvent difficiles à interpréter et n'apportent pas toujours plus d'informations que des représentations 2D intelligentes.
> 10. **Trop de Données sur un Seul Graphique** : L'overplotting rend le graphique illisible. Considérez des sous-graphiques ou des techniques d'agrégation.
> 11. **Mauvaise Utilisation des Couleurs** : Utiliser trop de couleurs ou des couleurs qui n'ont pas de sens peut créer de la confusion.
> 12. **Ignorer les Valeurs Aberrantes** : Elles peuvent fausser l'interprétation des distributions.
%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %%
> [!nav]
> ↩ [[Analyse et Données/Data Science/Data Mining/Data Mining|Accueil · Data Mining]]
>
> | [[Analyse et Données/Data Science/Data Mining/Cours 1 - Data mining avec python\|← Cours 1 - Data mining avec python]] | [[Analyse et Données/Data Science/Data Mining/Cours 3 - Data mining avec python\|Cours 3 - Data mining avec python →]] |
> |:---|---:|
%% nav-fin %%