Cours : Visualisation de données sur Seaborn

Généralités

Tout replier Tout déplier

Sélectionner l’activité Zone texte et média

Ce cours est un tutoriel sur les différentes fonctionnalités de Seaborn. Un jupyter notebook sera fourni que vous pourrez tester sur GoogleCollab mais si vous voulez le faire tourner en local vous aurez besoin d'un environnement python et du nécessaire pour lire un jupyter notebook. L'intégralité du cours peut se faire sur la page Moodle mais un diaporama contenant les informations du cours est aussi disponible dans la partie Ressources. La formation peut être suivie au rythme voulue mais un ordre de grandeur pour une lecture de la formation est d'environ 2h.
Sélectionner l’activité Annonces

Annonces Forum

Ressources

Marqué

Sélectionner l’activité Diapositives Seaborn

Diapositives Seaborn Fichier
Sélectionner l’activité NoteBook Seaborn

NoteBook Seaborn Fichier
Sélectionner l’activité Afin d'accéder au notebook il vous suffit de le té...
Afin d'accéder au notebook il vous suffit de le télécharger, c'est un fichier au format ipynb et :

de l'ouvrir avec l'IDE(integrated development environment, ou environnement de développement intégré en français, comme VSCode) de votre choix si vous souhaitez l'utiliser en local, de posséder un environnement python et en pensant que vous devrez avoir installer la librairie Seaborn dans votre environnement.

d'avoir un compte Google afin de transférer le fichier ipynb dans votre google drive puis double cliquer dessus. L'avantage est que vous n'aurez pas à installer quoi que ce soit de cette manière.

Python 3 — matplotlib & seaborn supportés
import seaborn as sns import matplotlib.pyplot as plt import pandas as pd df = pd.DataFrame({ "jour": ["Lun","Mar","Mer","Jeu","Ven"], "valeur": [4, 7, 3, 8, 5] }) fig, ax = plt.subplots(figsize=(6, 3)) sns.barplot(data=df, x="jour", y="valeur", palette="Blues_d", ax=ax) ax.set_title("Ventes de la semaine") plt.tight_layout()
← Clique sur Exécuter (premier lancement ~15 sec, chargement des packages)

Introduction

Sélectionner l’activité Introduction
Seaborn est une bibliothèque Python utilisée pour faire des visualisations de données (graphiques) de manière simple et esthétique.

Seaborn peut s'utiliser avec différents types de données, que ce soit des listes python, des tableaux numpy ou des dataframes pandas, bien que le dataframe de pandas soit à privilégier.

Il y a différents formats de tableaux de données :

Wide-format :

Var1 Valeur1 Valeur2 Valeur3

Var2

Valeur1 Var3Val11 Var3Val12 Var3Val13

Valeur2 Var3Val21 Var3Val22 Var3Val23

Valeur3 Var3Val31 Var3Val32 Var3Val33

Le wide format est souvent plus naturel pour les humains, et certains algorithmes ou fonctions attendent ce format. Voici un exemple :

Jour Temp_Paris Temp_Lyon

Lundi 20 23

Mardi 19 24

Long-format :

Var1 Var2 Var3

Observation1 Var1Val1 Var2Val1 Var3Val1

Observation2 Var1Val2 Var2Val2 Var3Val2

Observation3 Var1Val3 Var2Val3 Var3Val3

Le format classique est le long-format qui permet d'avoir des points de données avec beaucoup de variables différentes. Voici l'exemple précédent en long-format :

Jour Ville Température

Lundi Paris 20

Lundi Lyon 23

Mardi Paris 19

Mardi Lyon 24

Voici une description d'un tableau dans ce format :

Il peut être intéressant de vérifier si des données sont manquantes, notamment si des algorithmes ne peuvent pas le supporter ou si ca risque de biaiser les résultats, ou le simple fait qu'avoir des données complètes facilite l'aggrégation de données par exemple. Voici le code permettant de le vérifier :

data=sns.load_dataset("penguins") print(data.isnull())#sur le tableau entier print(data.isnull().any())#sur chaque colonne

Puis si l’on ne veut pas considérer les observations avec valeurs nulles pour une variable par exemple :

data.dropna(subset=["body_mass_g"])

Il faut cependant faire attention si l'on a un dataset plutôt petit, et si par exemple les données manquantes appartiennent toujours à la même variable cela peut introduire un biai. C'est au final à l'appréciation de l'utilisateur.

Ce cours comprend des cellules de code modifiables et exécutables. La structure sera toujours la même dans chaque sous-section : Tout d'abord une cellule servant à importer les librairies nécessaires et récupérer les datasets que nous utiliserons, puis dans le reste de la sous-section des cellules de codes modifiables pour illustrer les différentes fonctions.

Données quantitatives

- Replier Déplier
  Définition
  
  Sélectionner l’activité Que sont les données numériques? Les données quant...
  
  Que sont les données quantitatives?
  
  Les données quantitatives, ou numériques, comme leur nom l'indique, sont constituées des données mesurables, donc des nombres.
  
  Nous allons présenter et tester les différents types de graphiques que l'on peut faire avec Seaborn.

Relplot

La fonction relplot() permet de faire des graphiques de type nuage de points et de type courbe.

Voici la signature de la fonction :

Signature relplot

Il y évidemment une documentation accessible sur internet, donc on ne va passer que sur les éléments les plus essentiels pour pouvoir afficher ce dont on a besoin le plus vite possible, à savoir :

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
x	variable du tableau utilisée pour les abscisses	Chaine de caractères correspondant à une variable du tableau	x="poids"
y	variable du tableau utilisée pour les ordonnées	Chaine de caractères correspondant à une variable du tableau	y=”taille”
hue	variable du tableau permettant de rajouter une dimension avec de la couleur	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	hue=”age”
size	variable du tableau qui controlera la taille des points	Chaine de caractères correspondant à une variable du tableau, numérique	size=”argent”
style	variable du tableau qui controlera le style des points	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	style=”sex”
row	variable du tableau qui permettra de créer un tableau de graphiques, ici les lignes	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	row=”catégorie”
col	variable du tableau qui permettra de créer un tableau de graphiques, ici les colonnes	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	col=”métier”
kind	type de graphique que l’on veut	Chaine de caractères, 2 choix possibles	kind=”scatter” ou kind=”line”

Voici un exemple avec le code suivant, que vous pouvez exécuter :

 Code d'importation
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
data = pd.read_csv(open_url(url))
← Exécution

 Cellule 2
sns.relplot(data=data,x="bill_length_mm",y="bill_depth_mm",hue="species",style="sex",size="body_mass_g",col="island")← Exécution

On peut constater que col permet de faire différents graphiques sur une même figure, hue permet à l'aide de couleurs de distinguer une variable et style permet à l'aide de la forme des points de distinguer une autre variable. Vous pouvez tester différents paramètres et relancer le code.

On peut rajouter des ellipses sur des relplot scatter, pour dessiner dessus il faut récupérer l’ax :

 Cellule 3
from matplotlib.patches import Ellipse

g = sns.relplot(
    data=data,
    x="bill_length_mm",
    y="body_mass_g",
    hue="species",
    kind="scatter",
    height=5
)
ax = g.ax

def add_confidence_ellipse(x, y, ax, n_std=2.0, **kwargs):
    # Supprimer les NaN avant le calcul
    mask = ~(np.isnan(x) | np.isnan(y))
    x, y = x[mask], y[mask]
    if len(x) < 2:
        return
    cov = np.cov(x, y)
    mean = np.mean(x), np.mean(y)
    eigvals, eigvecs = np.linalg.eigh(cov)
    order = eigvals.argsort()[::-1]
    eigvals, eigvecs = eigvals[order], eigvecs[:, order]
    angle = np.degrees(np.arctan2(*eigvecs[:, 0][::-1]))
    width, height = 2 * n_std * np.sqrt(eigvals)
    ellipse = Ellipse(
        xy=mean,
        width=width,
        height=height,
        angle=angle,
        fill=False,
        **kwargs
    )
    ax.add_patch(ellipse)

palette = sns.color_palette()

for i, species in enumerate(data["species"].unique()):
    subset = data[data["species"] == species]
    add_confidence_ellipse(
        subset["bill_length_mm"].values,
        subset["body_mass_g"].values,
        ax,
        edgecolor=palette[i],
        linewidth=2
    )

ax.set_xlabel("Bill length (mm)")
ax.set_ylabel("Body mass (g)")
ax.set_title("95% Confidence Ellipse by Species — Penguins")← Exécution

Ellipse vient de matplotlib.patches.

On peut aussi afficher des lignes en modifiant le kind en "line" :

 Cellule 4
sns.relplot(data=data,x="bill_length_mm",y="bill_depth_mm",hue="species",style="sex",col="island",kind="scatter")
← Exécution

size n'est pas utilisable avec le graphique de kind "lines".
Cette fois style modifie le style de ligne selon la valeur de la variable "sex".

Displot

Le displot() permet d'afficher différents types de distributions.

signature displot

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
x	variable du tableau utilisée pour les abscisses	Chaine de caractères correspondant à une variable du tableau	x="poids"
y	variable du tableau utilisée pour les ordonnées	Chaine de caractères correspondant à une variable du tableau	y=”taille”
hue	variable du tableau permettant de rajouter une dimension avec de la couleur	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	hue=”age”
row	variable du tableau qui permettra de créer un tableau de graphiques, ici les lignes	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	row=”catégorie”
col	variable du tableau qui permettra de créer un tableau de graphiques, ici les colonnes	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	col=”métier”
kind	type de graphe que l’on veut	Chaine de caractères, 3 choix possibles	kind=”hist”,kind=”kde” ou kind=”ecdf”
rug	permet de voir les observations individuelles sur les axes.	Booléen	rug=True

 Code d'importation
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
data = pd.read_csv(open_url(url))
← Exécution

Voila un code modifiable d'exemple qui permet de faire un histogramme:

 Cellule 2
sns.displot(data=data, x="bill_length_mm", rug=True, hue="sex", bins=20)
← Exécution

Si l’on ne renseigne pas la donnée à mettre en ordonnée y, l’ordonnée sera le nombre d’occurence, et si l’on ne renseigne pas le kind c’est un histogramme par défaut. L’argument bins controle le nombre de barres. Le paramètre rug permet de voir les observations individuelles sur les axes du graphique.

Nous avons aussi accès à la kernel density estimation(KDE) pour estimer une distribution. Voici un code d'exemple d'utilisation :

 Cellule 3
sns.displot(data=data,x="bill_length_mm", rug=True, hue="sex", kind="kde")
← Exécution

Si l'on renseigne une variable pour y :

 Cellule 4
sns.displot(data=data,x="bill_length_mm", y="bill_depth_mm", rug=True, hue="sex", kind="kde")
← Exécution

Un graphique de ce type se lit comme une carte de niveau. Chaque ligne correspond à des points ayant des densités de probabilités proches. Les centres de lignes sont les zones de plus haute densité.

Le dernier type de distribution disponible est l'ECDF(empirical distribution function). On ne peut pas renseigner y pour cette distribution étant donné qu'elle est monovariationnelle.

data = sns.load_dataset("penguins")
sns.displot(data=data, x="body_mass_g", rug=True, hue="sex", kind="ecdf", row="species", col="sex", height=5)
plt.show()

 Cellule 5
sns.displot(data=data, x="body_mass_g", rug=True, hue="sex", kind="ecdf", row="species", col="sex", height=5)
← Exécution

Le paramètre row permet d'afficher encore plus de graphique selon une autre variable des données, les données comportent 3 espèces de pingouins on a donc 3 lignes de graphique, il y a 2 sexes dans les données on a donc 2 colonnes. height permet de contrôler la hauteur des graphiques.

Boxplot et Violinplot

Une représentation graphique de données classique est la boîte à moustache qui est accessible via boxplot().

signature boxplot

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
x	variable du tableau utilisée pour les abscisses	Chaine de caractères correspondant à une variable du tableau	x="poids"
y	variable du tableau utilisée pour les ordonnées	Chaine de caractères correspondant à une variable du tableau	y=”taille”
hue	variable du tableau permettant de rajouter une dimension avec de la couleur	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	hue=”age”
dodge	variable permettant de choisir si les graphiques peuvent se superposer	Booléen	dodge=False
width	Variable permettant de contrôler les largeurs des boîtes.	Valeur flottante	width=0.5
gap	Variable permettant de contrôler l’écart entre les différentes boîtes “dodgées”	Valeur flottante	gap=0.1

Voici un exemple de code que vous pouvez modifier et exécuter : :

 Code d'importation
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
data = pd.read_csv(open_url(url))
← Exécution

 Cellule 2
sns.boxplot(data=data, x="bill_length_mm", hue="island", dodge=True, width=0.5)
← Exécution

De base gap vaut 0. L’orientation est gérée automatiquement par seaborn, mais si le graphique est bidimensionnel avec 2 variables numériques on peut la chosir avec orient qui vaut "h" ou "v".

 Cellule 3
sns.boxplot(data=data, x="bill_length_mm", hue="island", dodge=True, width=0.5, gap=0.1, log_scale=True)
← Exécution

log_scale permet de changer l’échelle. Une valeur numérique définit la base, qui de base est la base 10. Si le graphique est bidimensionnel 2 valeurs peuvent être données, une pour chaque axe.

Le diagramme en violon est aussi accessible via violinplot().

signature violinplot

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
x	variable du tableau utilisée pour les abscisses	Chaine de caractères correspondant à une variable du tableau	x="poids"
y	variable du tableau utilisée pour les ordonnées	Chaine de caractères correspondant à une variable du tableau	y=”taille”
hue	variable du tableau permettant de rajouter une dimension avec de la couleur	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	hue=”age”
inner	variable permettant de contrôler la représentation des données dans le violon	Chaine de caractères correspondant à un type de représentation	inner=”box”,inner=”quart”,inner=”point”
split	Variable permettant de choisir si la représentation est symétrique.	Booléen	split=True
width	Variable permettant de contrôler la largeur des violons.	Valeur flottante	width=0.5
dodge	variable permettant de choisir si les graphes peuvent se superposer	Booléen	dodge=False
gap	Variable permettant de contrôler l’écart entre les différentes boîtes “dodgées”	Valeur flottante	gap=0.1

Voici un exemple de code à exécuter :

 Cellule 3
sns.violinplot(data=data, x="bill_length_mm", hue="sex", dodge=True, linewidth=3, split=True, inner="point")
← Exécution

split permet d'afficher 2 distributions sur un même violinplot, étant donnés que ceux-ci sont symétriques. linewidth contrôle l'épaisseur des lignes de contour.

Nous avons affiché les points individuels dans le violin plot mais nous pouvons choisir d'afficher une boîte à moustache miniature avec inner="box" :

 Cellule 4
sns.violinplot(data=data, x="bill_length_mm", hue="sex",dodge=True,linewidth=3, split=True, inner="box")
← Exécution

Regplot et Lmplot

Si l'on souhaite faire des régressions linéaires, seaborn a une fonction prédisposée : regplot().

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
x	variable du tableau utilisée pour les abscisses	Chaine de caractères correspondant à une variable du tableau	x="poids"
y	variable du tableau utilisée pour les ordonnées	Chaine de caractères correspondant à une variable du tableau	y=”taille”
ci	variable permettant de contrôler l’intervalle de confiance affiché	Entier entre 0 et 100.	ci=99
nboot	variable permettant d’indiquer le nombre de réechantillonage bootstrap réalisés.	Entier	nboot=100
seed	variable indiquant une graine pour le bootstrap. Permet la reproductibilité.	Entier	seed=42
logistic	Variable permettant de choisir de faire une régression logistique	Booléen	logistic=True
lowess	Variable permettant de choisir de faire une régression LOWESS.	Booléen	lowess=True
robust	Variable permettant de choisir de faire une régression robuste.	Booléen	robust=True

regplot() permet aussi d'afficher l'intervalle de confiance de la courbe, par défaut à 95%.

Voici un exemple de code modifiable :

 Code d'importation
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
import statsmodels
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
data = pd.read_csv(open_url(url))
← Exécution

 Cellule 2
sns.regplot(data=data, x="bill_length_mm",y="bill_depth_mm", ci=70)
← Exécution

Ici nous sommes confiant à 70% que la vraie courbe se trouve dans l'intervalle affiché sur le graphique. nboot de base vaut 1000, augmenter cette valeur entrainera forcément un temps d'exécution plus long du code car il devra faire des rééchantillonages supplémentaires. seed permet de pour en voir toujours reproduire les mêmes échantillonages utilisant un entier "graine", pratique pour la reproductibilité lors de l'écriture d'un article scientifique ou pour vérifier le fonctionnement d'une méthode.

On peut modifier le type en choisissant une méthode de régression, par exemple le paramètre lowess et en le mettant à True :

 Cellule 3
sns.regplot(data=data, x="bill_length_mm", y="bill_depth_mm",
 ci=99, lowess=True)
← Exécution

L’intervalle de confiance n’est pas affiché lorsque l’on utilise une lowess.

Une autre option est le lmplot() qui est plus adapté pour faire des régression mais sur plusieurs graphiques :

signature lmplot

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
x	variable du tableau utilisée pour les abscisses	Chaine de caractères correspondant à une variable du tableau	x="poids"
y	variable du tableau utilisée pour les ordonnées	Chaine de caractères correspondant à une variable du tableau	y=”taille”
hue	variable du tableau permettant de rajouter une dimension avec de la couleur	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	hue=”age”
row	variable du tableau qui permettra de créer un tableau de graphiques, ici les lignes	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	row=”catégorie”
col	variable du tableau qui permettra de créer un tableau de graphiques, ici les colonnes	Chaine de caractères correspondant à une variable du tableau, catégorielle ou entière	col=”métier”
ci	variable permettant de contrôler l’intervalle de confiance affiché	Entier entre 0 et 100.	ci=99
nboot	variable permettant d’indiquer le nombre de réechantillonage bootstrap réalisés.	Entier	nboot=100
lowess	Variable permettant de choisir de faire une régression LOWESS.	Booléen	lowess=True

Voici un exemple de code :

 Cellule 4
sns.lmplot(data=data, x="bill_length_mm", y="bill_depth_mm", ci=95, hue="island", robust=True, col="sex")
← Exécution

Les régressions robust et logistic sont aussi disponibles comme pour regplot(). nboot et seed aussi.

Heatmap et Clustermap

Seaborn permet aussi de faire des heatmap avec heatmap().

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
cmap	Couleurs de la heatmap. Soit une palette de matplotlib soit une personalisée.	Chaîne de caractères correspondant à une palette ou une color_palette de seaborn.	cmap=”viridis” ou cmap = sns.color_palette("light:blue", as_cmap=True)
annot	Variable qui choisit si on affiche les valeurs des cellules	Booléen	annot=True, vaut False par défaut
vmin	Valeur minimum qui sera prise en compte pour la colormap	Valeur flottante	vmin=30.6
vmax	Valeur maximale qui sera prise en compte pour la colormap	Valeur flottante	vmax=42
linecolor	Variable permettant de choisir la couleur des lignes entre les cellules.	Chaîne de caractère correspondant à une couleur	linecolor=”blue”
linewidths	Variable contrôlant l’épaisseur des lignes entre les cellules	Valeur flottante	linewidths=0.2 ou linewidths=10
mask	Variable permettant de contrôler les valeurs prises en compte dans la heatmap.	Tableau de booléen au même format que data.	mask=tableau_mask

Voici un exemple de code :

 Code d'importation
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
import scipy
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/glue.csv"
glue = pd.read_csv(open_url(url)).pivot(index="Model",columns="Task",values="Score")
← Exécution

Cellule 2

← Exécution

On utilise pivot afin de formater les données dans l'ordre que l'on veut :

index donne la variable des ordonnées
columns donne la variable des abscisses
values doit être une variable numérique et c'est ce que la heatmap va colorer.

Cellule 3

← Exécution

Avec les paramètres vmin et vmax on peut choisir la plage de valeur sur laquelle la heatmap s'appliquera, et on a aussi des options graphiques comme avec linecolor et linewidths pour les lignes entre les cases. annot affiche les valeurs sur chaque case de la heatmap.

Si l'on a besoin d'avoir du clustering sur la heatmap on peut utiliser la clustermap() de Seaborn. Chose à savoir cette fonction nécessite scipy, il faudra donc l'installer sur l'environnement sur lequel vous travaillez. Si vous êtes sur le Collab, ca ne sera pas nécessaire vous pourrez l'importer directement.

signature clustermap

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
method	Méthode scipy pour faire le clustering	Chaîne de caractère correspondant à une méthode de scipy	method=’centroid’
metric	Métrique scipy utilisée pour faire le clustering	Chaîne de caractère correspondant à une métrique de scipy	metric=’jaccard’
z_score	Variable permettant de centrer et réduire les données.	0 pour centrer et réduire les lignes, 1 pour les colonnes	z_score=0
standard_scale	Variable permettant de normaliser les données.	0 pour normaliser les lignes, 1 pour les colonnes	standard_scale=1
row_cluster, col_cluster	Variables permettant de choisir les axes de clustering	Booléen	row_cluster=False, faut True par défaut
figsize	Variable contrôlant la taille de la figure	tuple(largeur,hauteur)	figsize=(4,4)
dendrogram_ratio	Variable contrôlant le ratio de taille des dendogram	tuple(ratio de ligne, ratio de colonne)	dendrogram_ratio=(0.2,0.1)
cbar_pos	Variable contrôlant la position de la barre de couleur.	tuple(gauche,bas,largeur,hauteur)	cbar_pos=(0,0.1,0.05,0.6)

Voici un exemple de code :

 Cellule 4
url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
iris = pd.read_csv(open_url(url))
species = iris.pop("species")
#Partie modifiable
sns.clustermap(iris)
← Exécution

On retire la variable en trop avec pop() pour pouvoir faire le clustering qui est "species", on la réutilisera juste après.

Les dendrogrammes sont les arbres sur le côté de la clustermap qui représentent les différents regroupement effectués.

Maintenant explorons différents paramètres :

 Cellule 5
lut = dict(zip(species.unique(), sns.color_palette("Set2", species.nunique())))
row_colors = species.map(lut)
sns.clustermap(iris,row_cluster=True,dendrogram_ratio=(0.3,0.1),row_colors=row_colors,method="weighted",metric="correlation",z_score=1,annot=True,figsize=(7,12),cbar_pos=(0,0.1,0.02,0.8))
← Exécution

row_cluster permet de regrouper les lignes selon leur similarité pour faire apparaitre des groupes. dendrogram_ratio permet de contrôler la taille des dendrogrammes, la première valeur est pour celui à gauche et la seconde celui en haut. row_colors permet de rajouter une couleur à côté des lignes. Ici avec les lignes précédentes on a l'espèce de chaque ligne de renseignée. metric permet de choisir la distance de similarité utilisée et method l'algorithme utilisé pour faire les regroupements. z_score à 1 indique qu'on normalise sur les lignes. cbar_pos permet de choisir la position de la cbar. annot permet d'afficher les valeurs de chaque case. figsize permet de contrôler la taille de la figure.

Données qualitatives

- Replier Déplier
  Définition
  
  Sélectionner l’activité Les données qualitatives, ou catégorielles, sont, ...
  
  Que sont les données qualitatives?
  
  Les données qualitatives, ou catégorielles, sont, par opposition aux données quantitatives, toutes les données autres que des nombres. On peut retrouver des chaines de caractères (pour des noms par exemple) ou des booléens (True/False, oui/non, 1/0, ...).
  
  Les données qualitatives sont tout à fait plotables avec les outils vus précédemment. Mais il existe un outil tout-en-un qui permet de passer d’un style à l’autre facilement.

Catplot

La fonction catplot() permet de faire différents types de graphe :

signature catplot

Nom du paramètre	Explications	Ce qui lui faut comme format	Exemple
data	Il faut donner au paramètre data le tableau entier que vous traitez	DataFrame, Series, dict, array, or list of arrays	data=tableau
cmap	Couleurs de la heatmap. Soit une palette de matplotlib soit une personalisée.	Chaîne de caractères correspondant à une palette ou une color_palette de seaborn.	cmap=”viridis” ou cmap = sns.color_palette("light:blue", as_cmap=True)
annot	Variable qui choisit si on affiche les valeurs des cellules	Booléen	annot=True, vaut False par défaut
vmin	Valeur minimum qui sera prise en compte pour la colormap	Valeur flottante	vmin=30.6
vmax	Valeur maximale qui sera prise en compte pour la colormap	Valeur flottante	vmax=42
linecolor	Variable permettant de choisir la couleur des lignes entre les cellules.	Chaîne de caractère correspondant à une couleur	linecolor=”blue”
linewidths	Variable contrôlant l’épaisseur des lignes entre les cellules	Valeur flottante	linewidths=0.2 ou linewidths=10
mask	Variable permettant de contrôler les valeurs prises en compte dans la heatmap.	Tableau de booléen au même format que data.	mask=tableau_mask

Il y a différents kind que nous pouvons utiliser :

strip
swarm
violin
box
boxen
point
bar
count

 Code d'importation
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv"
tips = pd.read_csv(open_url(url))
← Exécution

 Cellule 2
sns.catplot(data=tips, x="day", y="total_bill", kind="strip")
← Exécution

Les graphiques "point" et "bar" affichent la moyenne ainsi que l'intervalle de confiance sur cette moyenne car elles sont calculées avec du rééchantillonnage bootstrap.

Nous pouvons utiliser les paramètres des méthodes choisies. Par exemple les boxplot() ont le paramètre fill donc on peut le spécifier dans la fonction catplot().

 Cellule 3
sns.catplot(kind="box", data=tips, x="smoker", y="total_bill", fill=False)
← Exécution

Représentation de plusieurs graphiques

Sélectionner l’activité Seaborn dispose de plusieurs fonctions permettant ...
Seaborn dispose de plusieurs fonctions permettant de tracer plusieurs graphiques différents en même temps.

Commençons par le jointplot(). Avec celui-ci on peut afficher un graphique avec des données en x et y, et sur les axes de ce graphique afficher un autre graphique représentant la distribution de la variable de chaque axe. Voici un exemple avec le dataset penguins :

Code d'importation
import pandas as pd import seaborn as sns import seaborn.objects as so import numpy as np import matplotlib.pyplot as plt from pyodide.http import open_url url_pengs = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv" url_tips = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv" tips = pd.read_csv(open_url(url_tips)) data=pd.read_csv(open_url(url_pengs))
← Exécution

Cellule 2
g=sns.jointplot(data=data, x="bill_length_mm", y="bill_depth_mm", kind="kde", hue="species") for species in data["species"].unique(): subset = data[data["species"] == species] g.ax_joint.scatter( subset["bill_length_mm"], subset["bill_depth_mm"], s=subset["body_mass_g"]/500, label=species, alpha=0.7)
← Exécution

La boucle for du code permet d'afficher les points en plus des graphiques. C'est du code matplotlib.

Une alternative permettant d'avoir plus de contrôle et de personnalisation est le JointGrid(). On peut notamment utiliser des types de graphiques différents entre le central et ceux sur les axes.

Cellule 3
g = sns.JointGrid(data=data, x="bill_length_mm", y="bill_depth_mm", hue="species") g.plot_joint(sns.scatterplot) g.plot_marginals(sns.kdeplot, fill=True)
← Exécution

plot_joint() contrôle le type de graphique central et plot_marginals() ceux sur les axes.

Un autre type de représentation est le pairplot(). Elle permet de représenter dans une figure les graphiques de chaque paire de variable possible, ainsi qu'une distribution de chaque variable sur la diagonale. Si nos données ont les variables x,y et z nous aurons les graphiques :

x selon y, y selon x

y selon z, z selon y

z selon x, x selon z

Et sur la diagonale la distribution de x, y et z.

Cellule 4
sns.pairplot(data=data, hue="species")
← Exécution

On peut modifier le type de graphique sur la diagonale et autour avec diag_kind pour la diagonale et kind pour le reste. diag_kind ne peut prendre que "hist" ou "kde" comme valeur, et on a accès au "scatter" pour kind, qui en est la valeur par défaut.

Comme pour les jointplot(), les pairplot() ont leur complémentaire permettant plus de contrôle et de personnalisation, la PairGrid(). Avec celle-ci on peut par exemple choisir des types de graphiques différents au dessus et en dessous de la diagonale.

Cellule 5
g = sns.PairGrid(data, hue="species") g.map_upper(sns.histplot) g.map_lower(sns.kdeplot, fill=True) g.map_diag(sns.histplot, kde=True)
← Exécution

map_upper(), map_lower() et map_diag() permettent de contrôler les différents types de graphique de la figure, qui peuvent être n'importe quel type de fonction Seaborn acceptant x et y.

Enfin nous avons la représentation FacetGrid() qui ne permet pas automatiquement de créer différents graphiques dans une figure mais de le faire de manière manuelle avec col et row et de pouvoir modifier des graphiques individuellement dans la figure, c'est une fonction qui se rapproche un peu plus de matplotlib :

Cellule 6
g = sns.FacetGrid(tips,col="sex",row="time",margin_titles=True, despine=False,sharex=False) g.figure.subplots_adjust(wspace=0.05, hspace=0.2) for (row_val, col_val), ax in g.axes_dict.items(): subset = tips[(tips["time"] == row_val) & (tips["sex"] == col_val)] if row_val == "Lunch" and col_val == "Female": subset = subset[subset["tip"] > 2] sns.scatterplot(data=subset,x="total_bill",y="tip",hue="smoker", ax=ax) ax.set_facecolor(".3") ax.set_xlim(0,20) ax.set_ylim(0,30) ax.set_xticks([0, 5, 15]) ax.set_xlabel("tip>2") ax.grid(True, color="gray", linestyle="-", linewidth=0.5) ax.spines["top"].set_color("red") ax.spines["right"].set_color("red") ax.spines["bottom"].set_color("red") ax.spines["left"].set_color("red") ax.tick_params(axis="x", colors="blue") else: ax.set_facecolor((0, 0, 0, 0)) sns.scatterplot(data=subset,x="total_bill",y="tip",hue="smoker", ax=ax)
← Exécution

Seaborn Object

- Replier Déplier
  Introduction
  
  Sélectionner l’activité Depuis la mise à jour 0.12 de Seaborn des objets s...
  
  Depuis la mise à jour 0.12 de Seaborn des objets seaborn ont été introduits. Ceux-ci constituent une alternative puissante aux fonctions de plot originelles. Les objects sont inspirés de ggplot2 de R.
  
  Nous allons prendre un exemple simple. Tout d'abord on importe les objets de la manière suivante :
  
  import seaborn.objects as so
  
  La manière de construire des graphiques avec les objets est spécifique. Une seule fonction permet de faire des graphiques :
  
  so.Plot()
  
  A celle-ci nous indiquons les données que nous allons utiliser :
  
  so.Plot(tips,x=”total_bill”)
  
  Ici tips est le dataset tips de Seaborn.
  
  Une fois que l'on a spécifié les données il reste à décider ce que nous allons en faire avec add(), ici un histogramme :
  
  so.Plot(tips,x=”total_bill”).add(so.Bar(),so.Hist()).show()
  
  Et voici le résultat :
- Replier Déplier
  Les types de graphique
  
  Sélectionner l’activité L'équivalent des scatterplot faisables avec les re...
  
  L'équivalent des scatterplot faisables avec les relplot() est l'objet Dot(). Après la cellule d'import tous les codes seront modifiables.
  
  Code d'importation
  import pandas as pd import seaborn as sns import seaborn.objects as so import numpy as np import matplotlib.pyplot as plt from pyodide.http import open_url url_tips = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv" url_diamonds = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv" url_healthexp = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/healthexp.csv" tips = pd.read_csv(open_url(url_tips)) diamonds=pd.read_csv(open_url(url_diamonds)) healthexp=pd.read_csv(open_url(url_healthexp))
  ← Exécution
  
  Cellule 2
  so.Plot(tips,x="smoker",y="tip").add(so.Dot(),so.Jitter(),color="day", marker="time").facet("sex").limit(y=(4,11)).show()
  ← Exécution
  
  color remplit le même rôle que le paramètre hue précédent, permettant de séparer les données selon une variable. marker permet d'utiliser une autre variable qui sera différenciée à l'aide de différents types de points, comme le paramètre style précédent. facet() remplit le même rôle que row et col. limit permet de restreindre les graphiques à des intervalles précis sur x et/ou y.
  
  Nous pouvons aussi facilement rajouter une courbe de régression avec Line() et Polyfit() :
  
  Cellule 3
  so.Plot(tips, x="total_bill", y="tip").add(so.Dot(), color="time", marker="day").facet("sex").add(so.Line(), so.PolyFit(), color="time").show()
  ← Exécution
  
  Cette même Line() peut avoir différents types comme Polyfit() mais peut aussi être utilisée en tant que représentation des données :
  
  Cellule 4
  diamonds.query("cut == 'Ideal' and (color == 'D' or color == 'F')").pipe(so.Plot, "depth","price",linestyle="color").add(so.Line(color=".1",linewidth=1),so.Agg()).add(so.Band(), so.Est(),group="color",color="color").show()
  ← Exécution
  
  Si l'on ne spécifie pas de type de Line() on relie les points de donnée avec des lignes. Chose intéressante avec le fait d'utiliser des DataFrame pandas, ce que rend la méthode load_dataset(), c'est que l'on peut utiliser .query() pour faire des requêtes type SQL pour sélectionner des données spécifiques. Ici nous prenons seulement les joyaux dont la "cut" est "Ideal" et avec certaines couleurs spécifiques. La fonction pipe() chainée permet de donner ce DataFrame selectionné en argument de la fonction Plot(), les autres arguments peuvent ensuite être donnés tels que x, y et linestyle. La ligne tracée ne correspond pas à chaque point d'observation, en effet l'utilisation de Agg() permet de faire de l'aggrégation de données : chaque "price" pour une "depth" donnée est aggrégée et moyennée dans le graphique. Les objets Band() et Est() permettent d'afficher l'incertitude des courbes.
  
  L'objet Path() est une alternative à Line(), idéale pour représenter des trajectoires car elle relit les points de données dans l'ordre dans lequel ils sont présentés.
  
  Cellule 5
  p = so.Plot(healthexp, "Spending_USD", "Life_Expectancy", color="Country").add(so.Path()).show()
  ← Exécution
  
  Si l'on veut afficher la surface sous des courbes, on utilise Area(). Le paramètre wrap de facet() permet de chosir combien de graphique il y aura par ligne.
  
  Cellule 6
  so.Plot(healthexp,"Year","Spending_USD").facet("Country",wrap=3).add(so.Area(),color="Country",legend=False).show()
  ← Exécution
  
  On peut empiler les surfaces avec Stack().
  
  Cellule 7
  so.Plot(healthexp,"Year","Spending_USD",color="Country").add(so.Area(),so.Stack()).show()
  ← Exécution
  
  L'objet Range() permet d'afficher des intervalles et nécessite des bornes ou un Est() pour calculer ce qu'il y a à afficher. Avec ce dernier on affiche la moyenne et l'intervalle de confiance. On peut aussi explicitement donner des bornes à afficher.
  
  Cellule 8
  df = pd.DataFrame({ "x": [1, 2, 3], "y": [10, 15, 20], "ymin": [8, 12, 17], "ymax": [12, 18, 23] }) so.Plot(df, x="x", y="y").add(so.Range(), ymin="ymin", ymax="ymax").show()
  ← Exécution
  
  Pour faire des histogrammes, on utilise Bar() avec Hist(). On peut choisir le type de statistique utilisée. Par défaut "count" est utilisé mais on peut choisir "density" pour des densités de probabilités, "percent" pour avoir des pourcentages, "probability" pour des proportions ou encore "frequency" pour la fréquence.
  
  Cellule 9
  so.Plot(tips,x="total_bill").add(so.Bar(),so.Hist(stat="density")).add(so.Line(color="red"),so.KDE()).show()
  ← Exécution
  
  On peut aussi utiliser Bar() pour afficher par exemple une moyenne avec Agg() qui permet de faire de l'aggrégation de données. Dodge() permet de faire la même chose que dodge des graphiques non objets.
  
  Cellule 10
  so.Plot(tips, "total_bill", "smoker", color="sex").add(so.Bar(alpha=.5), so.Agg(), so.Dodge()).add(so.Range(), so.Est(errorbar="sd"), so.Dodge()).show()
  ← Exécution
  
  Pour compter simplement des occurences, on utilise aussi Bar() mais avec Count().
  
  Cellule 11
  so.Plot(tips,y="day",color="smoker").add(so.Bar(),so.Count(),so.Stack()).show()
  ← Exécution
  
  On peut aussi utiliser les objets Seaborn pour afficher des percentiles avec Perc(). On peut choisir les percentiles que l'on souhaite afficher, et ici on les affiche sous forme de Dot(). Si l'on ne choisit rien de spécifique on affiche les percentiles [20,40,60,80,100].
  
  Cellule 12
  so.Plot(tips,"smoker","total_bill").add(so.Dot(marker="s"),so.Perc([10,50,90])).show()
  ← Exécution
  
  On peut faire un graphique ou l'on rajoute différents intervalles correspondants à des percentiles avec Range() que l'on déplace avec Shift() pour que ce soit visible. Ici scale() permet de modifier l'échelle sur les axes, celui des abscisses dans notre cas.
  
  Cellule 13
  so.Plot(diamonds, "price", "cut").add(so.Dots(pointsize=1, alpha=.2), so.Jitter(.3)).add(so.Range(color="k"), so.Perc([0, 25]), so.Shift(y=.2)).add(so.Range(color="k"), so.Perc([75, 100]), so.Shift(y=.2)).scale(x="log").show()
  ← Exécution
  
  On peut aussi normaliser les valeurs avec Norm(). Ici on normalise par rapport à l'année minimum, donc l'année 1970.
  
  Cellule 14
  so.Plot(healthexp, x="Year", y="Spending_USD", color="Country").add(so.Lines(), so.Norm(where="x == x.min()",percent=True)).show()
  ← Exécution
  
  Les objets Dot(), Line(), Path() et Bar() ont des variantes (Dots, Lines, etc.) plus adaptées aux gros volumes de données. Voici un exemple avec à gauche Bar() et à droite Bars().
  
  On peut aussi modifier l'échelle des axes avec scale(). Différents choix tels que "log" et "sqrt" sont disponibles, ainsi que "log2" et "log10".
  
  Cellule 15
  so.Plot(tips,x="total_bill",y="tip").add(so.Dots(),so.Jitter(0.5),color="day",marker="time").scale(x=so.Continuous(trans="log"),y=so.Continuous(trans="sqrt")).show()
  ← Exécution

Customisation graphique

Sélectionner l’activité Il y a différentes options visuelles disponibles s...

Il y a différentes options visuelles disponibles sur Seaborn, que ce soit au niveau du style de point, de courbe ou des couleurs.

Voila un exemple de code :

Code d'importation
import pandas as pd import seaborn as sns import seaborn.objects as so import numpy as np import matplotlib.pyplot as plt from pyodide.http import open_url url_tips = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv" url_healthexp = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/healthexp.csv" tips = pd.read_csv(open_url(url_tips)) healthexp=pd.read_csv(open_url(url_healthexp))
← Exécution

Cellule 2
so.Plot(tips, x="total_bill", y="tip").add(so.Dots(marker="x"), so.Jitter(0.5)).show()
← Exécution

Nous pouvons aussi modifier le type de lignes que nous utilisons :

Voici un exemple :

Cellule 3
so.Plot(tips,"total_bill","tip").add(so.Lines(linestyle='--')).show()
← Exécution

Nous pouvons aussi choisir des couleurs spécifiques :

Voici un exemple :

Cellule 4
so.Plot(tips, "total_bill", "tip", color="sex", linestyle="sex").add(so.Lines()).scale(color={"Male": "blue","Female": "red"}, linestyle={"Male": "--","Female": (4,4)}).show()
← Exécution

On peut aussi définir les couleurs à l'aide de palettes de couleur :

Et voici un exemple reprenant un code précédent :

Cellule 5
so.Plot(healthexp, x="Year", y="Spending_USD", color="Country").add(so.Lines(), so.Norm(where="x == x.min()", percent=True)).scale(color="rocket").label(y="Percent change in spending from 1970 baseline").show()
← Exécution