Visualisation Statistique avec Seaborn

Aperçu

Seaborn est une bibliothèque de visualisation Python pour créer des graphiques statistiques de qualité publication. Utilisez cette compétence pour la création de graphiques orientés données, l'analyse multivariée, l'estimation statistique automatique et les figures multi-panneaux complexes avec un minimum de code.

Philosophie de conception

Seaborn suit ces principes fondamentaux :

1. Orientée données : Travaillez directement avec des DataFrames et des variables nommées plutôt que des coordonnées abstraites
2. Mappage sémantique : Traduisez automatiquement les valeurs de données en propriétés visuelles (couleurs, tailles, styles)
3. Conscience statistique : Agrégation intégrée, estimation d'erreurs et intervalles de confiance
4. Esthétique par défaut : Thèmes prêts pour la publication et palettes de couleurs d'emblée
5. Intégration matplotlib : Compatibilité complète avec la personnalisation matplotlib si nécessaire

Démarrage rapide

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# Charger un exemple de dataset
df = sns.load_dataset('tips')

# Créer une visualisation simple
sns.scatterplot(data=df, x='total_bill', y='tip', hue='day')
plt.show()

Interfaces de traçage principales

Interface Fonction (Traditionnelle)

L'interface fonction fournit des fonctions de traçage spécialisées organisées par type de visualisation. Chaque catégorie a des fonctions axes-level (tracent sur un seul axes) et des fonctions figure-level (gèrent l'ensemble de la figure avec facettisation).

Quand l'utiliser :

• Analyse exploratoire rapide
• Visualisations à usage unique
• Quand vous avez besoin d'un type de graphique spécifique

Interface Objets (Moderne)

L'interface seaborn.objects fournit une API déclarative et composable similaire à ggplot2. Construisez des visualisations en enchaînant des méthodes pour spécifier les mappages de données, les marques, les transformations et les échelles.

Quand l'utiliser :

• Visualisations complexes en couches
• Quand vous avez besoin d'un contrôle affiné sur les transformations
• Construire des types de graphiques personnalisés
• Génération programmatique de graphiques

from seaborn import objects as so

# Syntaxe déclarative
(
    so.Plot(data=df, x='total_bill', y='tip')
    .add(so.Dot(), color='day')
    .add(so.Line(), so.PolyFit())
)

Fonctions de traçage par catégorie

Graphiques de Relations (Relations Entre Variables)

Utiliser pour : Explorer comment deux ou plusieurs variables se rapportent les unes aux autres

• scatterplot() - Afficher les observations individuelles sous forme de points
• lineplot() - Montrer les tendances et les changements (agrège automatiquement et calcule l'IC)
• relplot() - Interface figure-level avec facettisation automatique

Paramètres clés :

• x, y - Variables primaires
• hue - Codage couleur pour une variable catégorique/continue supplémentaire
• size - Codage de la taille des points/lignes
• style - Codage du style marqueur/ligne
• col, row - Facettiser en plusieurs sous-graphiques (figure-level uniquement)

# Nuage de points avec plusieurs mappages sémantiques
sns.scatterplot(data=df, x='total_bill', y='tip',
                hue='time', size='size', style='sex')

# Graphique linéaire avec intervalles de confiance
sns.lineplot(data=timeseries, x='date', y='value', hue='category')

# Graphique de relations facettisé
sns.relplot(data=df, x='total_bill', y='tip',
            col='time', row='sex', hue='smoker', kind='scatter')

Graphiques de Distribution (Distributions Univariées et Bivariées)

Utiliser pour : Comprendre l'étalement, la forme et la densité de probabilité des données

• histplot() - Distributions de fréquence basées sur barres avec binning flexible
• kdeplot() - Estimations de densité lisse utilisant des noyaux gaussiens
• ecdfplot() - Distribution cumulative empirique (aucun paramètre à ajuster)
• rugplot() - Marques de tick pour les observations individuelles
• displot() - Interface figure-level pour les distributions univariées et bivariées
• jointplot() - Graphique bivarié avec distributions marginales
• pairplot() - Matrice de relations pairwise sur le dataset

Paramètres clés :

• x, y - Variables (y optionnel pour univarié)
• hue - Séparer les distributions par catégorie
• stat - Normalisation : "count", "frequency", "probability", "density"
• bins / binwidth - Contrôle du binning de l'histogramme
• bw_adjust - Multiplicateur de la largeur de bande KDE (plus élevé = plus lisse)
• fill - Remplir l'area sous la courbe
• multiple - Comment gérer hue : "layer", "stack", "dodge", "fill"

# Histogramme avec normalisation de densité
sns.histplot(data=df, x='total_bill', hue='time',
             stat='density', multiple='stack')

# KDE bivarié avec contours
sns.kdeplot(data=df, x='total_bill', y='tip',
            fill=True, levels=5, thresh=0.1)

# Graphique joint avec marginales
sns.jointplot(data=df, x='total_bill', y='tip',
              kind='scatter', hue='time')

# Relations pairwise
sns.pairplot(data=df, hue='species', corner=True)

Graphiques Catégoriques (Comparaisons Entre Catégories)

Utiliser pour : Comparer des distributions ou statistiques entre catégories discrètes

Nuages de points catégoriques :

• stripplot() - Points avec jitter pour afficher toutes les observations
• swarmplot() - Points non chevauchants (algorithme beeswarm)

Comparaisons de distributions :

• boxplot() - Quartiles et valeurs aberrantes
• violinplot() - KDE + information sur les quartiles
• boxenplot() - Boxplot amélioré pour les datasets plus grands

Estimations statistiques :

• barplot() - Moyenne/agrégat avec intervalles de confiance
• pointplot() - Estimations ponctuelles avec lignes de connexion
• countplot() - Décompte des observations par catégorie

Figure-level :

• catplot() - Graphiques catégoriques facettisés (définir le paramètre kind)

Paramètres clés :

• x, y - Variables (généralement l'une catégorique)
• hue - Groupage catégorique supplémentaire
• order, hue_order - Contrôler l'ordre des catégories
• dodge - Séparer les niveaux hue côte à côte
• orient - "v" (vertical) ou "h" (horizontal)
• kind - Type de graphique pour catplot : "strip", "swarm", "box", "violin", "bar", "point"

# Swarm plot affichant tous les points
sns.swarmplot(data=df, x='day', y='total_bill', hue='sex')

# Violin plot avec split pour comparaison
sns.violinplot(data=df, x='day', y='total_bill',
               hue='sex', split=True)

# Bar plot avec barres d'erreur
sns.barplot(data=df, x='day', y='total_bill',
            hue='sex', estimator='mean', errorbar='ci')

# Graphique catégorique facettisé
sns.catplot(data=df, x='day', y='total_bill',
            col='time', kind='box')

Graphiques de Régression (Relations Linéaires)

Utiliser pour : Visualiser les régressions linéaires et les résidus

• regplot() - Graphique de régression axes-level avec nuage + ligne d'ajustement
• lmplot() - Figure-level avec support de facettisation
• residplot() - Graphique des résidus pour évaluer l'ajustement du modèle

Paramètres clés :

• x, y - Variables à régresser
• order - Ordre de régression polynomiale
• logistic - Ajuster une régression logistique
• robust - Utiliser une régression robuste (moins sensible aux valeurs aberrantes)
• ci - Largeur de l'intervalle de confiance (par défaut 95)
• scatter_kws, line_kws - Personnaliser les propriétés du nuage et de la ligne

# Régression linéaire simple
sns.regplot(data=df, x='total_bill', y='tip')

# Régression polynomiale avec facettisation
sns.lmplot(data=df, x='total_bill', y='tip',
           col='time', order=2, ci=95)

# Vérifier les résidus
sns.residplot(data=df, x='total_bill', y='tip')

Graphiques Matriciels (Données Rectangulaires)

Utiliser pour : Visualiser les matrices, corrélations et données structurées en grille

• heatmap() - Matrice codée par couleur avec annotations
• clustermap() - Heatmap hiérarchiquement regroupée

Paramètres clés :

• data - Dataset rectangulaire 2D (DataFrame ou array)
• annot - Afficher les valeurs dans les cellules
• fmt - Chaîne de format pour les annotations (ex. ".2f")
• cmap - Nom de la colormap
• center - Valeur au centre de la colormap (pour les colormaps divergentes)
• vmin, vmax - Limites de l'échelle de couleur
• square - Forcer les cellules carrées
• linewidths - Espacement entre les cellules

# Heatmap de corrélation
corr = df.corr()
sns.heatmap(corr, annot=True, fmt='.2f',
            cmap='coolwarm', center=0, square=True)

# Heatmap regroupée
sns.clustermap(data, cmap='viridis',
               standard_scale=1, figsize=(10, 10))

Grilles Multi-Graphiques

Seaborn fournit des objets grille pour créer des figures multi-panneaux complexes :

FacetGrid

Créer des sous-graphiques basés sur des variables catégoriques. Plus utile quand appelé via des fonctions figure-level (relplot, displot, catplot), mais peut être utilisé directement pour des graphiques personnalisés.

g = sns.FacetGrid(df, col='time', row='sex', hue='smoker')
g.map(sns.scatterplot, 'total_bill', 'tip')
g.add_legend()

PairGrid

Afficher les relations pairwise entre toutes les variables d'un dataset.

g = sns.PairGrid(df, hue='species')
g.map_upper(sns.scatterplot)
g.map_lower(sns.kdeplot)
g.map_diag(sns.histplot)
g.add_legend()

JointGrid

Combiner un graphique bivarié avec des distributions marginales.

g = sns.JointGrid(data=df, x='total_bill', y='tip')
g.plot_joint(sns.scatterplot)
g.plot_marginals(sns.histplot)

Fonctions Figure-Level vs Axes-Level

Comprendre cette distinction est crucial pour une utilisation efficace de seaborn :

Fonctions Axes-Level

• Tracent sur un seul objet matplotlib Axes
• S'intègrent facilement dans des figures matplotlib complexes
• Acceptent le paramètre ax= pour un positionnement précis
• Retournent un objet Axes
• Exemples : scatterplot, histplot, boxplot, regplot, heatmap

Quand l'utiliser :

• Construire des layouts multi-graphiques personnalisés
• Combiner différents types de graphiques
• Besoin de contrôle au niveau matplotlib
• Intégration avec du code matplotlib existant

fig, axes = plt.subplots(2, 2, figsize=(10, 10))
sns.scatterplot(data=df, x='x', y='y', ax=axes[0, 0])
sns.histplot(data=df, x='x', ax=axes[0, 1])
sns.boxplot(data=df, x='cat', y='y', ax=axes[1, 0])
sns.kdeplot(data=df, x='x', y='y', ax=axes[1, 1])

Fonctions Figure-Level

• Gèrent l'ensemble de la figure incluant tous les sous-graphiques
• Facettisation intégrée via les paramètres col et row
• Retournent des objets FacetGrid, JointGrid ou PairGrid
• Utilisent height et aspect pour le dimensionnement (par sous-graphique)
• Ne peuvent pas être placées dans une figure existante
• Exemples : relplot, displot, catplot, lmplot, jointplot, pairplot

Quand l'utiliser :

• Visualisations facettisées (petits multiples)
• Analyse exploratoire rapide
• Layouts multi-panneaux cohérents
• Pas besoin de combiner avec d'autres types de graphiques

# Facettisation automatique
sns.relplot(data=df, x='x', y='y', col='category', row='group',
            hue='type', height=3, aspect=1.2)

Exigences Relatives à la Structure des Données

Données en Forme Longue (Préférée)

Chaque variable est une colonne, chaque observation est une ligne. Ce format « tidy » fournit une flexibilité maximale :

# Structure longue
   subject  condition  measurement
0        1    control         10.5
1        1  treatment         12.3
2        2    control          9.8
3        2  treatment         13.1

Avantages :

• Fonctionne avec toutes les fonctions seaborn
• Facile de remapper les variables aux propriétés visuelles
• Supporte une complexité arbitraire
• Naturel pour les opérations DataFrame

Données en Forme Large

Les variables sont réparties sur les colonnes. Utile pour les données rectangulaires simples :

# Structure large
   control  treatment
0     10.5       12.3
1      9.8       13.1

Cas d'usage :

• Séries temporelles simples
• Matrices de corrélation
• Heatmaps
• Graphiques rapides de données array

Convertir large en long :

df_long = df.melt(var_name='condition', value_name='measurement')

Palettes de Couleurs

Seaborn fournit des palettes de couleurs soigneusement conçues pour différents types de données :

Palettes Qualitatives (Données Catégoriques)

Distinguer les catégories par la variation de teinte :

• "deep" - Défaut, couleurs vives
• "muted" - Plus doux, moins saturé
• "pastel" - Clair, désaturé
• "bright" - Très saturé
• "dark" - Valeurs foncées
• "colorblind" - Sûr pour la malvoyance des couleurs

sns.set_palette("colorblind")
sns.color_palette("Set2")

Palettes Séquentielles (Données Ordonnées)

Montrer la progression de faible à élevé :

• "rocket", "mako" - Plage de luminance large (bien pour les heatmaps)
• "flare", "crest" - Luminance restreinte (bien pour les points/lignes)
• "viridis", "magma", "plasma" - Matplotlib perceptuellement uniformes

sns.heatmap(data, cmap='rocket')
sns.kdeplot(data=df, x='x', y='y', cmap='mako', fill=True)

Palettes Divergentes (Données Centrées)

Mettre l'accent sur les écarts par rapport à un point milieu :

• "vlag" - Bleu à rouge
• "icefire" - Bleu à orange
• "coolwarm" - Froid à chaud
• "Spectral" - Arc-en-ciel divergent

sns.heatmap(correlation_matrix, cmap='vlag', center=0)

Palettes Personnalisées

# Créer une palette personnalisée
custom = sns.color_palette("husl", 8)

# Gradient clair à foncé
palette = sns.light_palette("seagreen", as_cmap=True)

# Palette divergente à partir de teintes
palette = sns.diverging_palette(250, 10, as_cmap=True)

Thématisation et Esthétique

Définir le Thème

set_theme() contrôle l'apparence générale :

# Définir le thème complet
sns.set_theme(style='whitegrid', palette='pastel', font='sans-serif')

# Réinitialiser aux défauts
sns.set_theme()

Styles

Contrôler l'apparence du fond et de la grille :

• "darkgrid" - Fond gris avec grille blanche (défaut)
• "whitegrid" - Fond blanc avec grille grise
• "dark" - Fond gris, pas de grille
• "white" - Fond blanc, pas de grille
• "ticks" - Fond blanc avec ticks d'axes

sns.set_style("whitegrid")

# Supprimer les spines
sns.despine(left=False, bottom=False, offset=10, trim=True)

# Style temporaire
with sns.axes_style("white"):
    sns.scatterplot(data=df, x='x', y='y')

Contextes

Mettre à l'échelle les éléments pour différents cas d'usage :

• "paper" - Le plus petit (défaut)
• "notebook" - Légèrement plus grand
• "talk" - Diapositives de présentation
• "poster" - Grand format

sns.set_context("talk", font_scale=1.2)

# Contexte temporaire
with sns.plotting_context("poster"):
    sns.barplot(data=df, x='category', y='value')

Bonnes Pratiques

1. Préparation des Données

Toujours utiliser des DataFrames bien structurés avec des noms de colonnes significatifs :

# Bon : Colonnes nommées dans DataFrame
df = pd.DataFrame({'bill': bills, 'tip': tips, 'day': days})
sns.scatterplot(data=df, x='bill', y='tip', hue='day')

# À éviter : Arrays sans nom
sns.scatterplot(x=x_array, y=y_array)  # Perd les labels d'axes

2. Choisir le Bon Type de Graphique

x continu, y continu : scatterplot, lineplot, kdeplot, regplot x continu, y catégorique : violinplot, boxplot, stripplot, swarmplot Une variable continue : histplot, kdeplot, ecdfplot Corrélations/matrices : heatmap, clustermap Relations pairwise : pairplot, jointplot

3. Utiliser les Fonctions Figure-Level pour la Facettisation

# Au lieu de créer manuellement des sous-graphiques
sns.relplot(data=df, x='x', y='y', col='category', col_wrap=3)

# Pas : Créer des subplots manuellement pour une facettisation simple

4. Exploiter les Mappages Sémantiques

Utilisez hue, size et style pour encoder des dimensions supplémentaires :

sns.scatterplot(data=df, x='x', y='y',
                hue='category',      # Couleur par catégorie
                size='importance',    # Taille par variable continue
                style='type')         # Style marqueur par type

5. Contrôler l'Estimation Statistique

De nombreuses fonctions calculent les statistiques automatiquement. Comprenez et personnalisez :

# Lineplot calcule la moyenne et l'IC 95% par défaut
sns.lineplot(data=df, x='time', y='value',
             errorbar='sd')  # Utiliser l'écart-type à la place

# Barplot calcule la moyenne par défaut
sns.barplot(data=df, x='category', y='value',
            estimator='median',  # Utiliser la médiane à la place
            errorbar=('ci', 95))  # IC bootstrappé

6. Combiner avec Matplotlib

Seaborn s'intègre parfaitement avec matplotlib pour le peaufinage :

ax = sns.scatterplot(data=df, x='x', y='y')
ax.set(xlabel='Custom X Label', ylabel='Custom Y Label',
       title='Custom Title')
ax.axhline(y=0, color='r', linestyle='--')
plt.tight_layout()

7. Enregistrer des Figures de Haute Qualité

fig = sns.relplot(data=df, x='x', y='y', col='group')
fig.savefig('figure.png', dpi=300, bbox_inches='tight')
fig.savefig('figure.pdf')  # Format vectoriel pour les publications

Modèles Courants

Analyse Exploratoire des Données

# Aperçu rapide de toutes les relations
sns.pairplot(data=df, hue='target', corner=True)

# Exploration des distributions
sns.displot(data=df, x='variable', hue='group',
            kind='kde', fill=True, col='category')

# Analyse de corrélation
corr = df.corr()
sns.heatmap(corr, annot=True, cmap='coolwarm', center=0)

Figures de Qualité Publication

sns.set_theme(style='ticks', context='paper', font_scale=1.1)

g = sns.catplot(data=df, x='treatment', y='response',
                col='cell_line', kind='box', height=3, aspect=1.2)
g.set_axis_labels('Treatment Condition', 'Response (μM)')
g.set_titles('{col_name}')
sns.despine(trim=True)

g.savefig('figure.pdf', dpi=300, bbox_inches='tight')

Figures Multi-Panneaux Complexes

# Utiliser les subplots matplotlib avec seaborn
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

sns.scatterplot(data=df, x='x1', y='y', hue='group', ax=axes[0, 0])
sns.histplot(data=df, x='x1', hue='group', ax=axes[0, 1])
sns.violinplot(data=df, x='group', y='y', ax=axes[1, 0])
sns.heatmap(df.pivot_table(values='y', index='x1', columns='x2'),
            ax=axes[1, 1], cmap='viridis')

plt.tight_layout()

Séries Temporelles avec Bandes de Confiance

# Lineplot agrège automatiquement et affiche l'IC
sns.lineplot(data=timeseries, x='date', y='measurement',
             hue='sensor', style='location', errorbar='sd')

# Pour plus de contrôle
g = sns.relplot(data=timeseries, x='date', y='measurement',
                col='location', hue='sensor', kind='line',
                height=4, aspect=1.5, errorbar=('ci', 95))
g.set_axis_labels('Date', 'Measurement (units)')

Dépannage

Problème : Légende en Dehors de la Zone de Traçage

Les fonctions figure-level placent les légendes à l'extérieur par défaut. Pour les déplacer à l'intérieur :

g = sns.relplot(data=df, x='x', y='y', hue='category')
g._legend.set_bbox_to_anchor((0.9, 0.5))  # Ajuster la position

Problème : Labels qui se Chevauchent

plt.xticks(rotation=45, ha='right')
plt.tight_layout()

Problème : Figure Trop Petite

Pour les fonctions figure-level :

sns.relplot(data=df, x='x', y='y', height=6, aspect=1.5)

Pour les fonctions axes-level :

fig, ax = plt.subplots(figsize=(10, 6))
sns.scatterplot(data=df, x='x', y='y', ax=ax)

Problème : Couleurs Pas Assez Distinctes

# Utiliser une palette différente
sns.set_palette("bright")

# Ou spécifier le nombre de couleurs
palette = sns.color_palette("husl", n_colors=len(df['category'].unique()))
sns.scatterplot(data=df, x='x', y='y', hue='category', palette=palette)

Problème : KDE Trop Lisse ou Dentelée

# Ajuster la largeur de bande
sns.kdeplot(data=df, x='x', bw_adjust=0.5)  # Moins lisse
sns.kdeplot(data=df, x='x', bw_adjust=2)    # Plus lisse

Ressources

Cette compétence inclut des matériaux de référence pour une exploration plus approfondie :

references/

• function_reference.md - Liste complète de toutes les fonctions seaborn avec paramètres et exemples
• objects_interface.md - Guide détaillé de l'API moderne seaborn.objects
• examples.md - Cas d'usage courants et modèles de code pour différents scénarios d'analyse

Charger les fichiers de référence selon vos besoins pour les signatures de fonction détaillées, les paramètres avancés ou des exemples spécifiques.