Histogrammes

Displot

displot : permet de faire des histogrammes et des courbes de densité.

seaborn.displot(v, color = 'green', kind = 'hist', rug = True) : trace l'histogramme des valeurs de v. Paramètres :

kind = 'kde' : courbe de densité plutôt qu'un histogramme
kind = 'ecdf' : courbe de densité cumulée (empirical cumulative distribution function). Elle a l'avantage de ne pas nécessiter de paramètre car on ne fait pas de bins.
bins : le nombre de bins
binwidth : la largeur d'un bin (alternative)
rug = True : trace les traits sur l'axe des x pour les différentes valeurs.
legend = False : supprime la légende.
hue_order : donne l'ordre des valeurs du paramètre hue s'il est défini.
col_wrap = 3 : quand row n'est pas défini, et qu'on a plus de 3 valeurs pour col, indique qu'il faut retourner à la ligne toutes les 3 valeurs
aspect = 2 : indique les graphes doivent être 2 fois plus larges que hauts.
la valeur retournée est un FacetGrid avec lequel on peut fixer des propriétés additionnelles : par exemple fg.set_xlabels('abscisse')


import random
random.seed(0)
v = [random.gauss(0, 1) for i in range(300)]
seaborn.displot(x = v, color = 'green', kind = 'hist', rug = True)

On peut tracer plusieurs histogrammes ou densités en fonction de certaines colonnes : seaborn.displot(x = 'v', data = df, color = 'green', hue = 'A', row = 'B', col = 'C', kind = 'kde', rug = True, palette = {'a': 'red', 'b': 'green', 'c': 'blue'})
Exemple complet :


import random
random.seed(0)
df = pandas.DataFrame({'v': [random.gauss(0, 1) for i in range(60)],
                       'A': sum([['a', 'b', 'c'] for i in range(20)], []),
                       'B': sum([['b1', 'b2'] for i in range(30)], []),
                       'C': sum([['c1', 'c2', 'c2', 'c1'] for i in range(15)], [])})
df.loc[df['A'] == 'b', 'v'] += 0.2
df.loc[df['A'] == 'c', 'v'] += 0.3
df.loc[df['B'] == 'b2', 'v'] += 0.1
df.loc[df['C'] == 'c2', 'v'] -= 0.1

fg = seaborn.displot(x = 'v', data = df, color = 'green', hue = 'A', row = 'B', col = 'C',
  kind = 'kde', rug = True, palette = {'a': 'red', 'b': 'green', 'c': 'blue'})
fg.set_xlabels('abscisse')
fg.set_ylabels('ordonnee')
fg.tight_layout()

Histplot

histplot : analogue à displot, avec kind = 'hist' (histogramme) :

seaborn.histplot(x = 'v', data = df, color = 'green', edgecolor = 'none', bins = 50, kde = True) : trace l'histogramme et en même temps l'estimation de densité (avec un noyau gaussien).
bins = range(-3, 3) : on peut donner une liste d'intervalles.
stat = 'count' : montre les comptes, le défaut. stat = 'frequency' : compte divisé par la largeur du bin, stat = 'density' : normalise pour que l'aire de l'histogramme soit 1, stat = 'probability' : normalise pour la somme des hauteurs des barres soit 1.
cumulative = True : pour faire une distribution cumulée.
element = 'bars' : trace des barres (le défaut), element = 'step' : trace seulement l'enveloppe des barres, element = 'poly' : trace un polygône.
line_kws = {'linewidth': 5, 'linestyle': 'dashed'} : permet de donner les propriétés de la ligne de densité (mais on ne peut pas donner color, ça ne change pas la couleur !).
seaborn.histplot(x = 'A', hue = 'B', data = df, multiple = 'dodge', bins = 100, stat = 'percent', common_norm = False) : fait plusieurs histogrammes pour les différentes valeurs de B côte à côte.
seaborn.histplot(..., stat = 'proportion') : la somme des barres fait 1
seaborn.histplot(..., stat = 'percent') : la somme des barres fait 100

Ecdfplot

Ca trace la distribution cumulée (Empirical Cumulative Distribution Function)

seaborn.ecdfplot(x = 'val', data = df) : trace la distribution cumulée pour la variable val du dataframe. Paramètres :

on peut utiliser y au lieu de x pour inverser les axes x et y.
stat = 'count' : indique les comptes plutôt que les proportions (défaut : stat = 'proportion')
complementary = True : trace la distribution complémentaire (1 - CDF)
ax = myAxis : indique l'axes à utiliser s'il existe déjà.
hue = 'myVar' : utilise une autre colonne myVar du dataframe pour faire plusieurs courbes.
hue_order : pour préciser l'ordre des hue
palette : permet d'indiquer les couleurs à utiliser.

Exemple :


import random
random.seed(0)
ind = range(200)
v = [random.gauss(0, 1) for i in ind] + [random.gauss(4, 1) for i in ind]
df = pandas.DataFrame({'val': v, 'lab': ['a' for i in ind] + ['b' for i in ind]})
seaborn.ecdfplot(x = 'val', data = df, hue = 'lab', hue_order = ['b', 'a'], palette = {'a': 'red', 'b': 'blue'})

Kdeplot

On peut aussi tracer directement la fonction de densité d'une variable

seaborn.kdeplot(x)
seaborn.kdeplot(x, fill = True, bw = 0.5) : avec remplissage de l'intérieur de la courbe et avec une largeur de bande de 0.5.
si on a un dataframe, on peut faire seaborn.kdeplot(x = 'A', data = df, fill = True)

on peut comparer 2 distributions facilement en faisant :

seaborn.kdeplot(x1, fill = True, bw = 0.5, label = 'first')
seaborn.kdeplot(x2, fill = True, bw = 0.5, label = 'second')
pyplot.legend()

Traçage d'une densité en 2 dimensions (avec 2 variables) :


import random
x = numpy.array([random.gauss(0, 1) for i in range(300)])
y =  x + numpy.array([random.gauss(0, 0.2) for i in range(300)])
seaborn.kdeplot(x = x, y = y, fill = True, n_levels = 7, cbar = True)

fill = True : gradations de couleurs plutôt que des courbes de niveau.
n_levels = 7 : nombre de niveaux.
c_bar = True : affiche une légende pour les niveaux de couleur.

Distributions 2d

Représentation d'une Distribution 2d :

seaborn.displot(x = 'v1', y = 'v2', data = df, color = 'green') : heatmap 2d.
cbar = True : affiche une barre de couleur pour les niveaux.
seaborn.displot(x = 'v1', y = 'v2', data = df, color = 'green', kind = 'kde') : avec des courbes de niveau.
seaborn.kdeplot(x = 'v1', y = 'v2', data = df, color = 'green') : autre formulation pour des courbes de niveau.
autres paramètres de kdeplot :
- levels = 20 : nombre de lignes de niveau
- bw_adjust = 0.5 : ajustage de la band width : plus elle est petite plus la représentation est fine (défaut est de 1)


import random
random.seed(0)
df = pandas.DataFrame({'v1': [random.gauss(0, 1) for i in range(100)],
                       'A': sum([['a', 'b'] for i in range(50)], [])})
df['v2'] = [df['v1'].loc[i] * (1 if df.loc[i, 'A'] == 'a' else -1) +
  random.gauss(0, 0.2) for i in range(len(df))]
seaborn.kdeplot(x = 'v1', y = 'v2', data = df, color = 'green', hue = 'A', levels = 8, bw_adjust = 1)

Traçage du nuage de points :

seaborn.jointplot(x, y) : trace par défaut le nuage de points, mais aussi les histogrammes pour chacune des 2 variables et calcule la corrélation de pearson et la p-value.
si on a un dataframe pandas df avec des colonnes A et B : on peut faire : seaborn.jointplot(x = "A", y = "B", data = df)


import random
x = numpy.array([random.gauss(0, 1) for i in range(300)])
y =  x + numpy.array([random.gauss(0, 0.2) for i in range(300)])
seaborn.jointplot(x = x, y = y)

color = 'red' : la couleur des graphes.
xlim = (-7, 7) : les limites sur l'axe des x.
ylim = (-7, 7) : les limites sur l'axe des y.
kind :
- kind = 'scatter' : nuage de points (le défaut)
- kind = 'reg' : une regression linéaire sur le nuage de points et une densité en plus de l'histogramme pour chacune des 2 variables.
- kind = 'kde' : une densité comme avec kdeplot à la fois pour le nuage de points 2d et chacun des 2 variables.
- kind = 'hex' : un pavage hexagonal pour le graphe 2d.
on peut rajouter des paramètres pour customiser le nuage de points (joint_kws) et/ou pour les histogrammes (marginal_kws) : seaborn.jointplot(x = "A", y = "B", data = df, marginal_kws = {'bins': 50, 'color': 'red'}, joint_kws = {'color': 'green', 'marker': '+'})

jointplot retourne un objet seaborn.axisgrid.JointGrid qui a des fonctions qui permettent de customiser le graphe ou de rajouter des éléments dessus.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert