12 KiB
title, author
| title | author |
|---|---|
| Analyse exploratoire des données | Steve Kossouho |
Analyse exploratoire des données
Dans le domaine de la science des données, l'Analyse exploratoire des données (AED) est une approche essentielle. Elle est utilisée pour comprendre la nature, la structure et la distribution des données en utilisant différentes techniques et outils. Python, avec ses nombreuses bibliothèques dédiées, s'avère être un outil puissant pour l'AED.
Métriques d’analyse
Pour analyser un ensemble de données, nous avons souvent besoin de calculer diverses métriques qui fournissent des informations précieuses. Dans un objet DataFrame de la bibliothèque Pandas, ces calculs sont simples à réaliser.
Prenons un exemple au hasard : un ensemble de données contenant les ventes d'un magasin. Les colonnes pourraient être "produit", "quantité vendue" et "prix unitaire". Nous pourrions vouloir connaître le produit le plus vendu, ou le produit générant le plus de revenus.
Voici un extrait de code illustrant ce calcul :
import pandas as pd
# Supposons que df est notre DataFrame
produit_plus_vendu = df['quantité vendue'].idxmax()
produit_plus_rentable = (df['quantité vendue'] * df['prix unitaire']).idxmax()
print(produit_plus_vendu, produit_plus_rentable)
Visualisation des données
La visualisation des données est un élément crucial de l'analyse exploratoire des données. Elle permet de représenter les données de manière graphique, ce qui facilite la compréhension de leurs structures et patterns.
Une bibliothèque couramment utilisée pour la visualisation des données en Python est Matplotlib, mais Pandas propose également des méthodes de tracé intégrées qui sont très utiles. Par exemple, pour tracer un histogramme de la colonne "quantité vendue" de notre DataFrame de vente, nous pouvons faire :
pip install matplotlib # dans un terminal
pip install pyside6 # nécessaire pour afficher une fenetre
from matplotlib import pyplot as plt
import pandas as pd
df = ... # notre dataframe
# Si notre dataframe contient des données, afficher un histogramme
df.plot.bar(x="produit", y="quantité vendue")
plt.show()
Documentation officielle des méthodes de diagrammes
Petit exemple pour l'histogramme
from matplotlib import pyplot as plt
import pandas as pd
# Créer un petit DataFrame
df = pd.DataFrame(data={
"produit": ["pomme", "poire", "raisin"],
"prix": [3, 2.79, 5.49]
})
# Créer le diagramme puis l'afficher
df.plot.bar(x="produit", y="prix")
plt.show()
Génération de graphes (Matplotlib)
Matplotlib est une bibliothèque de Python dédiée à la création de graphiques statiques, animés et interactifs. Elle offre une grande flexibilité pour personnaliser les graphiques selon les besoins spécifiques de l'utilisateur.
Pour utiliser Matplotlib, il faut d'abord l'installer. Si vous utilisez pip comme gestionnaire de paquets, vous pouvez l'installer en utilisant la commande suivante dans votre terminal :
pip install matplotlib
Une fois installée, Matplotlib peut être utilisée pour générer divers types de graphiques. Par exemple, pour générer un diagramme à barres montrant la quantité vendue pour chaque produit, nous pourrions faire :
import matplotlib.pyplot as plt
produits = df['produit'].unique()
quantités = [df[df['produit'] == produit]['quantité vendue'].sum() for produit in produits]
plt.bar(produits, quantités)
plt.xlabel('Produits')
plt.ylabel('Quantité Vendue')
plt.show()
Dans ce code, nous récupérons d'abord la liste unique des produits, puis calculons la quantité totale vendue pour
chaque produit. Enfin, nous utilisons plt.bar pour créer le diagramme à barres, et plt.show() pour afficher le graphique.
Création de graphiques à barres avec Matplotlib
Les graphiques à barres sont particulièrement utiles pour comparer des quantités relatives entre différentes catégories. Prenons l'exemple d'un ensemble de données contenant le nombre de ventes réalisées par chaque vendeur dans une entreprise.
import matplotlib.pyplot as plt
# Supposons que nous ayons une liste de vendeurs et leurs ventes respectives
vendeurs = ['Alice', 'Bob', 'Charlie', 'Dave']
ventes = [123, 156, 98, 127]
plt.bar(vendeurs, ventes)
plt.xlabel('Vendeurs')
plt.ylabel('Ventes')
plt.title('Nombre de ventes par vendeur')
plt.show()
Construction de graphiques à secteurs (camembert) avec Matplotlib
Les graphiques à secteurs (ou camembert) sont idéals pour illustrer la proportion d'éléments dans un ensemble.
Supposons que nous voulions visualiser la proportion des ventes totales réalisées par chaque vendeur.
plt.pie(ventes, labels=vendeurs, autopct='%1.1f%%')
plt.title('Proportion des ventes par vendeur')
plt.show()
Tracé de courbes avec Matplotlib
Les courbes sont un outil indispensable pour représenter l'évolution d'une quantité en fonction d'une autre. Imaginons que nous souhaitions tracer l'évolution des ventes d'un produit au fil du temps.
# Supposons que nous ayons une liste de mois et les ventes correspondantes
mois = ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Juin']
ventes = [110, 120, 115, 125, 150, 180]
plt.plot(mois, ventes)
plt.xlabel('Mois')
plt.ylabel('Ventes')
plt.title('Evolution des ventes au fil des mois')
plt.show()
Tracé de nuages de points avec Matplotlib
Les nuages de points sont excellents pour visualiser la corrélation entre deux variables quantitatives. Par exemple, si nous avions des données sur le prix d'un produit et le nombre de ces produits vendus, nous pourrions vouloir voir si ces deux variables sont corrélées.
# Supposons que nous ayons une liste de prix et une liste correspondante de quantités vendues
prix = [5, 10, 15, 20, 25, 30]
quantités_vendues = [105, 95, 90, 85, 80, 75]
plt.scatter(prix, quantités_vendues)
plt.xlabel('Prix')
plt.ylabel('Quantités vendues')
plt.title('Corrélation entre le prix et la quantité vendue')
plt.show()
Deuxième exemple de nuage de points
Dans cet exemple, on génère des coordonnées de points, disséminés autour d'une droite. L'objectif est ensuite d'en détecter une régression linéaire (et en afficher un segment dans le graphique).
Première étape : Générer les coordonnées
# On importe le nécessaire
import pandas as pd # pour le dataframe et le nuage de points
import numpy as np # pour la fonction de régression polynomiale
from random import random # pour générer des valeurs aléatoires
from matplotlib import pyplot as plt # pour afficher le graphique
# Créer des listes pour avoir les valeurs des deux axes
x = []
y = []
# Faire une boucle de 30 itérations pour créer des coordonnées pour X et Y
for nombre in range(30):
x.append(nombre)
y.append(nombre - 5 + random() * 10) # x - 5 <= y <= x + 5
# Convertir x et y en tableaux compatibles avec numpy et pandas
# Sans ça, je ne pourrai pas utiliser x et y pour dessiner la ligne de la régression linéaire
x = np.array(x)
y = np.array(y)
Deuxième étape : Construire un DataFrame et générer le diagramme
... # Reprendre le code précédent
# Créer un dataframe avec x et y
df = pd.DataFrame(data={"X": x, "Y": y})
# Afficher un nuage de points (scatter plot)
chart = df.plot.scatter(x="X", y="Y")
Troisième étape : Calculer la régression et générer la ligne
... # Reprendre le code précédent
# Pour afficher une ligne représentant la régression linéaire des points
# L'argument "1" indique le degré de la régression (premier degré donc linéaire).
# On récupère chaque coeff pour chaque degré de la régression.
coeff_niv1, constant = np.polyfit(x, y, 1)
plt.plot(x, coeff_niv1 * x + constant, color="orange")
plt.show() # Afficher le résultat
On aurait pu faire une régression du second degré plus ou moins de la même manière :
coeff_niv2, coeff_niv1, constant = np.polyfit(x, y, 2)
plt.plot(x, coeff_niv2 * (x ** 2) + coeff_niv1 * x + constant, color="orange")
plt.show() # Afficher le résultat
Et on aurait une courbe (normalement très légèrement incurvée, qui ressemble à la régression linéaire)
Tracé de diagramme à moustache (boîte)
En temps normal, un diagramme à moustache est une représentation de la dispersion des éléments d'une série, découpée en quartiles.
Pour afficher un DataFrame en diagramme à moustache, voici un exemple :
import pandas as pd
from matplotlib import pyplot as plt
# Créer un DataFrame avec deux séries de valeurs dans des colonnes A et B
df = pd.DataFrame(data={
"A": [1, 9, 11, 17, 6, 11, 14, 1],
"B": [20, 11, 13, 14, 15, 18, 14, 9]
})
# Tout simplement générer et afficher le graphique
df.plot.box()
plt.show()
Diagramme à moustache et valeurs aberrantes (outliers)
Il peut arriver que le tracé d'un diagramme à moustache contienne des petits cercles. Ces cercles représentent les valeurs des colonnes considérées comme aberrantes (statistiquement trop éloignées des autres valeurs).
L'exemple suivant le teste :
import pandas as pd
from matplotlib import pyplot as plt
# Créer un DataFrame avec deux séries de valeurs dans des colonnes A et B
# Beaucoup de valeurs sont proches les unes des autres, celles éloignées seront affichées en cercle, en dehors de la moustache.
df = pd.DataFrame(data={
"A": [1, 9, 41, 11, 25, 6, 81, 11, 14, 1],
"B": [125, 40, 71, 11, 13, 14, 15, 18, 14, 1]
})
# Tout simplement générer et afficher le graphique
df.plot.box()
plt.show()
Comment savoir si une valeur est aberrante
Diagramme en bougie (cours de bourse et tendances)
Les diagrammes en bougie sont en général utilisés pour donner des informations sur le suivi des cours de bourse (permettent simplement de voir pour des périodes données, les valeurs d'un cours en début et fin de période, ainsi que les valeurs extrêmes d'un cours durant lesdites périodes).
Matplotlib n'est pas capable de générer ce genre de diagramme, mais plotly
le peut (et c'est gratuit).
Plotly
Plotly est une bibliothèque très compétente et disponible avec Python pour générer des graphiques.
Pour installer la bibliothèque, il suffit dans un terminal :
pip install plotly
Exemple avec Plotly
Supposons que j'ai dans un DataFrame des données de cours sur uniquement trois jours (avec des infos sur le cours à l'ouverture de la période, à la fermeture, et les extrêmes sur la même période) :
import pandas as pd
import plotly.graph_objects as go
# Créer un Dataframe avec les données
df = pd.DataFrame(data={
"day": ["2023-05-10", "2023-05-11", "2023-05-12"],
"open": [10, 15, 16],
"close": [14, 15.9, 13.8],
"high": [14, 16.8, 16.05],
"low": [9.97, 15, 13.7]
})
# Convertir la colonne de date dans le type datetime
df["day"] = pd.to_datetime(df["day"])
# Générer un diagramme Plotly qui contient le graphique en bougie
# Dans les arguments de la classe de diagramme Candlestick, les arguments
# x, open, high, low, et close vont recevoir respectivement les données des
# colonnes correspondantes de notre DataFrame.
fig = go.Figure(data=[
go.Candlestick(x=df['day'], open=df['open'], high=df['high'], low=df['low'], close=df['close'])])
# Afficher le diagramme, qui sera affiché dans un navigateur web
fig.show()