Boxplots, stripplot, swarmplot, violinplot, barplot

catplot est la fonction générique qui permet de faire des plots d'une variable quantitative en fonction d'une variable catégorie : des stripplot, des swarmplots, des boxplot, des violinplot, des boxenplot, des pointplot, barplot ou countplot :

• df = pandas.DataFrame({'X': ['a', 'b', 'a', 'b', 'b', 'a', 'b'], 'Y': [1, 2, 3, 4, 7, 5, 8],
                         'T': ['A', 'A', 'A', 'B', 'B','B', 'A']})
  
  seaborn.catplot(x = 'X', y = 'Y', data = df, kind = 'strip')
      

• kind peut prendre les valeurs 'strip' (défaut, pour dessiner des points), 'swarm' (pour dessiner des points décalés quand il y a besoin pour éviter tout chevauchement), 'box' (boxplot), 'violin' (violinplot), 'boxen' (boxplot amélioré), 'point' (un seul point avec une barre d'erreur), 'bar' (une barre avec une barre d'erreur), 'count' (pour compter le nombre de fois qu'une valeur de type catégorie apparait avec une seule variable).
• comme avec relplot, on peut dessiner plusieurs graphes en ligne ou en colonne en fonction des valeurs d'une ou 2 variables : seaborn.catplot(x = 'X', y = 'Y', data = df, col = 'T') (ou avec row, ou les deux).
• les fonctions individuelles (stripplot, swarmplot, ...) ne permettent pas de dessiner plusieurs graphes.
• catplot renvoie un objet seaborn.axisgrid.FacetGrid qu'on peut utiliser pour modifier les graphes

Ce sont ici les représentations d'une variable continue en fonction de catégories. Les valeurs peuvent être fournies de différentes façons :

• soit sous forme de vecteurs : seaborn.boxplot(x = ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B'], y = [2, 4, 5, 7, 9, 16, 7, 12])
• soit sous forme de dataframe avec une ligne par individu (le plus commode) : df = pandas.DataFrame({'X': ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B'], 'Y': [2, 4, 5, 7, 9, 16, 7, 12]}); seaborn.boxplot(x = 'X', y = 'Y', data = df)
• soit sous forme de dataframe avec une colonne par catégorie : df = pandas.DataFrame({'A': [2, 4, 5, 7], 'B': [9, 16, 7, 12]}); seaborn.boxplot(data = df)

Stripplot : permet de représenter un nuage de points 1d pour chaque valeur de catégorie :

• seaborn.stripplot(day, temperature) : la catégorie est en premier.
• on peut utiliser un dataframe pandas : seaborn.stripplot(x = 'day', y = 'temperature', data = df).

df = pandas.DataFrame({'X': ['A', 'A', 'A', 'B', 'B', 'B', 'B'], 'Y': [2, 4, 5, 9, 16, 7, 12], 'Z': ['a', 'b', 'a', 'b', 'a', 'b', 'a']}) seaborn.stripplot(x = 'X', y = 'Y', hue = 'Z', order = ['B', 'A'], hue_order = ['b', 'a'], palette = {'a': 'red', 'b': 'blue'}, jitter = 0.2, size = 10, data = df)

• order = ['B', 'A'] : l'ordre dans lequel on trie les catégories.
• hue_order = ['b', 'a'] : l'ordre pour la variable hue.
• palette = {'a': 'red', 'b': 'blue'} : le dictionnaire pour les couleurs à utiliser pour hue
• jitter = 0.2 : de combien on bruite les données. jitter = True (ou jitter = 1) bruite les données de manière raisonnable.
• size = 10 : taille des marqueurs
• marker = 'D' : symbole à utiliser.
• alpha = 0.25 : transparence à utiliser pour les symboles
• orient = 'h' : orientation horizontale plutôt que verticale.
• dodge = True : décale les valeurs des différentes hue.
• on peut combiner un boxplot et un stripplot :

  df = pandas.DataFrame({'X': ['A', 'A', 'A', 'B', 'B', 'B', 'B'], 'Y': [2, 4, 5, 9, 16, 7, 12],
                         'Z': ['a', 'b', 'a', 'b', 'a', 'b', 'a']})
  seaborn.boxplot(x = 'X', y = 'Y', data = df)
  seaborn.stripplot(x = 'X', y = 'Y', jitter = True, size = 10, color = 'gray', data = df)
      

Swarmplot :

• comme un stripplot, mais en évitant les recouvrements entre les points.
• peu adapté si très nombre de points.
• exemple avec un dataframe pandas : seaborn.swarmplot(x = 'day', y = 'temperature', hue = 'country', data = df)

Si warning car trop grand nombre de points, on peut essayer de diminuer la taille des points : size = 2 (le défaut est 5).

Si on veut faire un graphe swarmplot en coordonnées log :

• on risque d'avoir des problèmes car la dispersion est appliquée avant la constitution du graphe, donc moins de dispersion dans les valeurs élevées. Donc, il faut d'abord déclarer un graphe en coordonnées log avant de faire le graphe.
• Exemple :

  logAxis = pyplot.gcf().add_axes((0.15, 0.15, 0.8, 0.8))
  logAxis.set_yscale('log')
  seaborn.swarmplot(x = 'experiment', y = 'value', hue = 'type', data = df, ax = logAxis)
      

Boxplot :

• seaborn.boxplot(x = 'X', y = 'Y', data = df) : x est la variable de type catégorie, y est la variable continue.

df = pandas.DataFrame({'X': ['A', 'A', 'A', 'B', 'B', 'B', 'B'], 'Y': [2, 4, 5, 9, 16, 7, 12], 'Z': ['a', 'b', 'a', 'b', 'a', 'b', 'a']}) seaborn.boxplot(x = 'X', y = 'Y', hue = 'Z', order = ['B', 'A'], hue_order = ['b', 'a'], palette = {'a': 'orange', 'b': 'yellow'}, saturation = 1, width = 0.5, linewidth = 0.5, data = df)

• width = 0.5 : la largeur des boîtes (défaut est de 0.8)
• color = 'skyblue' : la couleur à utiliser
• saturation = 1 : par défaut, les couleurs sont désaturées (valeur de 0.75), on peut choisir un niveau de saturation (1 si saturation complète)
• linewidth = 0.5 : pour avoir des traits plus fins
• order = ['B', 'A'] : pour imposer un ordre dans les catégories
• hue = 'Z'
• hue_order = ['b', 'a'] : l'ordre des valeurs de hue
• palette = {'a': 'orange', 'b': 'yellow'} : dictionnaire des couleurs à utiliser pour hue
• orient = 'h' : orientation horizontale plutôt que verticale.
• pour tourner les étiquettes de 90 degrés : ax = seaborn.boxplot(...); pyplot.setp(ax.get_xticklabels(), rotation = 90)
• fliersize = 0 : évite de montrer les points outliers en mettant leur taille à 0.
• whis = 0 : n'affiche pas la whisker (moustache).

Configuration avancée en modifiant les couleurs :

• seaborn.boxplot(x = 'myCateg', y = 'myValue', data = df, color = 'white', boxprops = {'edgecolor': 'blue'}, medianprops = {'color': 'red'}, capprops = {'color': 'green'}, whiskerprops = {'color': 'orange'}, showfliers = False)
• voir la documentation de matplotlib.axes.Axes.boxplot

On peut superposer un swarmplot au-dessus d'un boxplot : df = pandas.DataFrame({'X': ['A', 'B', 'A', 'A', 'B', 'A', 'A', 'B'], 'Y': [3, 7, 2, 4, 8, 4, 3.5, 7.2]}) seaborn.boxplot(x = 'X', y = 'Y', data = df, color = 'skyblue', fliersize = 0) seaborn.swarmplot(x = 'X', y = 'Y', data = df, color = 'blue')

Violinplot :

• similaire au boxplot, mais représente la densité au moyen d'un kernel
• surtout utile si suffisamment de données.
• seaborn.violinplot(x = 'X', y = 'Y', data = df)

Modifier les couleurs d'un violinplot :

seaborn.violinplot(x = 'myCateg', y = 'myValue', data = df, color = 'white')
for art in pyplot.gca().get_children():
    if type(art) in [matplotlib.collections.PolyCollection, matplotlib.collections.PathCollection]:
        art.set(edgecolor = 'black')
    elif type(art) == matplotlib.lines.Line2D:
        art.set(color = 'black')
  

Evolution du boxplot, avec plus de quantiles.

Exemple : df = pandas.DataFrame({'X': ['A', 'A', 'A', 'B', 'B', 'B', 'B'], 'Y': [2, 4, 5, 9, 16, 7, 12], 'Z': ['a', 'b', 'a', 'b', 'a', 'b', 'a']}) seaborn.boxenplot(x = 'X', y = 'Y', hue = 'Z', color = 'red', data = df)

boxenplot :

• prend toutes les options de boxplot

Barplot :

• barplot simple :

  df = pandas.DataFrame({'X': ['A', 'B', 'C'], 'Y': [2, 5, 16], 'e': [1, 3, 2]})
  seaborn.barplot(x = 'X', y = 'Y', color = 'yellow', data = df)
      

• pas possible de faire de barplot empilé avec seaborn : on peut le faire avec pandas :

  df = pandas.DataFrame({'categ': ['A', 'B'], 'var1': [1, 3], 'var2': [3, 3], 'var3': [4, 2]})
  df.set_index('categ').plot(kind = 'bar', stacked = True)
      

Barres d'erreurs sur les barplots :

• soit on conserve toutes les données et on laisse seaborn calculer la standard deviation :

  df = pandas.DataFrame({'X': ['A', 'A', 'A', 'B', 'B', 'B'], 'Y': [2, 4, 6, 12, 15, 18]})
  seaborn.barplot(x = 'X', y = 'Y', color = 'yellow', ci = 'sd', data = df)
      

• soit on a déjà calculé les standard deviation et on ne peut pas utiliser la formulation où l'on donne les colonnes du dataframe. Il faut faire :

  df = pandas.DataFrame({'X': ['A', 'B'], 'Y': [4, 15], 'sd': [1.63, 2.45]})
  seaborn.barplot(df['X'], df['Y'], color = 'yellow', ci = 'sd', yerr = df['sd'])
      

• c'est seulement avec la première façon que l'on peut adapter les propriétés des barres d'erreur :

df = pandas.DataFrame({'X': ['A', 'A', 'A', 'B', 'B', 'B'], 'Y': [2, 4, 6, 12, 15, 18]}) seaborn.barplot(x = 'X', y = 'Y', color = 'yellow', ci = 'sd', errcolor = 'red', errwidth = 0.5, capsize = 0.2, data = df)

• errcolor = 'red' : couleur de la barre d'erreur.
• errwidth = 0.5 : épaisseur du trait.
• capsize = 0.2 : petits traits horizontaux.