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(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', 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 !).

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, 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, 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