Seaborn - Guide rapide

Dans le monde d'Analytics, la meilleure façon d'obtenir des informations est de visualiser les données. Les données peuvent être visualisées en les représentant sous forme de tracés faciles à comprendre, à explorer et à saisir. Ces données aident à attirer l'attention sur des éléments clés.

Pour analyser un ensemble de données à l'aide de Python, nous utilisons Matplotlib, une bibliothèque de traçage 2D largement implémentée. De même, Seaborn est une bibliothèque de visualisation en Python. Il est construit sur Matplotlib.

Seaborn Vs Matplotlib

On résume que si Matplotlib «essaie de rendre les choses faciles faciles et les choses difficiles possibles», Seaborn essaie également de rendre facile un ensemble bien défini de choses difficiles. »

Seaborn aide à résoudre les deux problèmes majeurs rencontrés par Matplotlib; les problèmes sont -

Paramètres Matplotlib par défaut
Travailler avec des blocs de données

Comme Seaborn complimente et prolonge Matplotlib, la courbe d'apprentissage est assez progressive. Si vous connaissez Matplotlib, vous êtes déjà à mi-chemin de Seaborn.

Caractéristiques importantes de Seaborn

Seaborn repose sur la bibliothèque de visualisation principale de Python Matplotlib. Il est censé servir de complément et non de remplacement. Cependant, Seaborn est livré avec des fonctionnalités très importantes. Voyons quelques-uns d'entre eux ici. Les fonctionnalités aident à -

Thèmes intégrés pour styliser les graphiques matplotlib
Visualisation des données univariées et bivariées
Ajustement et visualisation des modèles de régression linéaire
Tracer des données de séries chronologiques statistiques
Seaborn fonctionne bien avec les structures de données NumPy et Pandas
Il est livré avec des thèmes intégrés pour styliser les graphiques Matplotlib

Dans la plupart des cas, vous utiliserez toujours Matplotlib pour un traçage simple. La connaissance de Matplotlib est recommandée pour modifier les graphiques par défaut de Seaborn.

Dans ce chapitre, nous aborderons la configuration de l'environnement pour Seaborn. Commençons par l'installation et comprenons comment commencer à mesure que nous progressons.

Installation de Seaborn et mise en route

Dans cette section, nous comprendrons les étapes de l'installation de Seaborn.

Utilisation de Pip Installer

Pour installer la dernière version de Seaborn, vous pouvez utiliser pip -

pip install seaborn

Pour Windows, Linux et Mac utilisant Anaconda

Anaconda (à partir de https://www.anaconda.com/est une distribution Python gratuite pour la pile SciPy. Il est également disponible pour Linux et Mac.

Il est également possible d'installer la version publiée en utilisant conda -

conda install seaborn

Pour installer la version de développement de Seaborn directement depuis github

https://github.com/mwaskom/seaborn"

Dépendances

Considérez les dépendances suivantes de Seaborn -

Python 2.7 ou 3.4+
numpy
scipy
pandas
matplotlib

Dans ce chapitre, nous verrons comment importer des ensembles de données et des bibliothèques. Commençons par comprendre comment importer des bibliothèques.

Importation de bibliothèques

Commençons par importer Pandas, qui est une excellente bibliothèque pour gérer des ensembles de données relationnelles (au format table). Seaborn est pratique lorsqu'il s'agit de DataFrames, qui est la structure de données la plus largement utilisée pour l'analyse des données.

La commande suivante vous aidera à importer des Pandas -

# Pandas for managing datasets
import pandas as pd

Maintenant, importons la bibliothèque Matplotlib, qui nous aide à personnaliser nos graphiques.

# Matplotlib for additional customization
from matplotlib import pyplot as plt

Nous importerons la bibliothèque Seaborn avec la commande suivante -

# Seaborn for plotting and styling
import seaborn as sb

Importer des ensembles de données

Nous avons importé les bibliothèques requises. Dans cette section, nous allons comprendre comment importer les jeux de données requis.

Seaborn est livré avec quelques ensembles de données importants dans la bibliothèque. Lorsque Seaborn est installé, les jeux de données sont téléchargés automatiquement.

Vous pouvez utiliser l'un de ces ensembles de données pour votre apprentissage. Avec l'aide de la fonction suivante, vous pouvez charger le jeu de données requis

load_dataset()

Importation de données en tant que Pandas DataFrame

Dans cette section, nous importerons un ensemble de données. Cet ensemble de données se charge par défaut en tant que Pandas DataFrame. S'il y a une fonction dans le Pandas DataFrame, cela fonctionne sur ce DataFrame.

La ligne de code suivante vous aidera à importer l'ensemble de données -

# Seaborn for plotting and styling
import seaborn as sb
df = sb.load_dataset('tips')
print df.head()

La ligne de code ci-dessus générera la sortie suivante -

total_bill  tip   sex    smoker day  time   size
0    16.99    1.01   Female  No    Sun  Dinner  2
1    10.34    1.66   Male    No    Sun  Dinner  3
2    21.01    3.50   Male    No    Sun  Dinner  3
3    23.68    3.31   Male    No    Sun  Dinner  2
4    24.59    3.61   Female  No    Sun  Dinner  4

Pour afficher tous les ensembles de données disponibles dans la bibliothèque Seaborn, vous pouvez utiliser la commande suivante avec le get_dataset_names() fonction comme indiqué ci-dessous -

import seaborn as sb
print sb.get_dataset_names()

La ligne de code ci-dessus renverra la liste des ensembles de données disponibles comme sortie suivante

[u'anscombe', u'attention', u'brain_networks', u'car_crashes', u'dots', 
u'exercise', u'flights', u'fmri', u'gammas', u'iris', u'planets', u'tips', 
u'titanic']

DataFramesstocker les données sous la forme de grilles rectangulaires permettant de visualiser facilement les données. Chaque ligne de la grille rectangulaire contient les valeurs d'une instance et chaque colonne de la grille est un vecteur qui contient des données pour une variable spécifique. Cela signifie que les lignes d'un DataFrame n'ont pas besoin de contenir, les valeurs du même type de données, elles peuvent être numériques, caractères, logiques, etc. Les DataFrames pour Python sont livrés avec la bibliothèque Pandas, et ils sont définis comme des structures de données étiquetées bidimensionnelles avec des types de colonnes potentiellement différents.

Pour plus de détails sur les DataFrames, visitez notre tutoriel sur les pandas.

La visualisation des données est une étape et rendre les données visualisées plus agréables en est une autre. La visualisation joue un rôle essentiel dans la communication d'informations quantitatives à un public pour attirer son attention.

L'esthétique signifie un ensemble de principes concernant la nature et l'appréciation de la beauté, en particulier dans l'art. La visualisation est un art de représenter les données de la manière la plus efficace et la plus simple possible.

La bibliothèque Matplotlib prend fortement en charge la personnalisation, mais savoir quels paramètres modifier pour obtenir un tracé attrayant et anticipé est ce dont il faut être conscient pour l'utiliser. Contrairement à Matplotlib, Seaborn est livré avec des thèmes personnalisés et une interface de haut niveau pour personnaliser et contrôler l'apparence des figurines Matplotlib.

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5): 
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
sinplot()
plt.show()

Voici à quoi ressemble un tracé avec les valeurs par défaut Matplotlib -

Pour changer le même tracé en valeurs par défaut Seaborn, utilisez le set() fonction -

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5):
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set()
sinplot()
plt.show()

Production

Les deux figures ci-dessus montrent la différence entre les graphiques par défaut de Matplotlib et de Seaborn. La représentation des données est la même, mais le style de représentation varie dans les deux.

Fondamentalement, Seaborn divise les paramètres de Matplotlib en deux groupes -

Styles de tracé
Échelle de tracé

Styles de figurines Seaborn

L'interface de manipulation des styles est set_style(). En utilisant cette fonction, vous pouvez définir le thème du tracé. Selon la dernière version mise à jour, vous trouverez ci-dessous les cinq thèmes disponibles.

Darkgrid
Whitegrid
Dark
White
Ticks

Essayons d'appliquer un thème de la liste ci-dessus. Le thème par défaut du tracé seradarkgrid ce que nous avons vu dans l'exemple précédent.

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5):
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("whitegrid")
sinplot()
plt.show()

Production

La différence entre les deux tracés ci-dessus est la couleur d'arrière-plan

Retirer les épines des haches

Dans les thèmes blancs et coches, nous pouvons supprimer les épines des axes supérieur et droit à l'aide du bouton despine() fonction.

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5):
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("white")
sinplot()
sb.despine()
plt.show()

Production

Dans les graphiques réguliers, nous utilisons uniquement les axes gauche et inférieur. En utilisant ledespine() fonction, nous pouvons éviter les épines inutiles des axes droit et supérieur, ce qui n'est pas pris en charge dans Matplotlib.

Remplacer les éléments

Si vous souhaitez personnaliser les styles Seaborn, vous pouvez transmettre un dictionnaire de paramètres au set_style() fonction. Les paramètres disponibles sont affichés à l'aide deaxes_style() fonction.

Exemple

import seaborn as sb
print sb.axes_style

Production

{'axes.axisbelow'     : False,
'axes.edgecolor'      : 'white',
'axes.facecolor'      : '#EAEAF2',
'axes.grid'           : True,
'axes.labelcolor'     : '.15',
'axes.linewidth'      : 0.0,
'figure.facecolor'    : 'white',
'font.family'         : [u'sans-serif'],
'font.sans-serif'     : [u'Arial', u'Liberation  
                        Sans', u'Bitstream Vera Sans', u'sans-serif'],
'grid.color'          : 'white',
'grid.linestyle'      : u'-',
'image.cmap'          : u'Greys',
'legend.frameon'      : False,
'legend.numpoints'    : 1,
'legend.scatterpoints': 1,
'lines.solid_capstyle': u'round',
'text.color'          : '.15',
'xtick.color'         : '.15',
'xtick.direction'     : u'out',
'xtick.major.size'    : 0.0,
'xtick.minor.size'    : 0.0,
'ytick.color'         : '.15',
'ytick.direction'     : u'out',
'ytick.major.size'    : 0.0,
'ytick.minor.size'    : 0.0}

La modification des valeurs de l'un des paramètres modifie le style de tracé.

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5):
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("darkgrid", {'axes.axisbelow': False})
sinplot()
sb.despine()
plt.show()

Production

Mise à l'échelle des éléments de tracé

Nous contrôlons également les éléments de la parcelle et pouvons contrôler l'échelle de la parcelle à l'aide du set_context()fonction. Nous avons quatre modèles prédéfinis pour les contextes, basés sur la taille relative, les contextes sont nommés comme suit

Paper
Notebook
Talk
Poster

Par défaut, le contexte est défini sur notebook; et a été utilisé dans les graphiques ci-dessus.

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5):
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("darkgrid", {'axes.axisbelow': False})
sinplot()
sb.despine()
plt.show()

Production

La taille de sortie du tracé réel est plus grande que celle des tracés ci-dessus.

Note - En raison de la mise à l'échelle des images sur notre page Web, vous pourriez manquer la différence réelle dans nos graphiques d'exemple.

La couleur joue un rôle important que tout autre aspect dans les visualisations. Lorsqu'elle est utilisée efficacement, la couleur ajoute plus de valeur au tracé. Une palette signifie une surface plane sur laquelle un peintre dispose et mélange les peintures.

Palette de couleurs du bâtiment

Seaborn fournit une fonction appelée color_palette(), qui peut être utilisé pour donner des couleurs aux tracés et leur ajouter plus de valeur esthétique.

Usage

seaborn.color_palette(palette = None, n_colors = None, desat = None)

Paramètre

Le tableau suivant répertorie les paramètres de création de la palette de couleurs -

N ° Sr.	Palatte et description
1	n_colors Nombre de couleurs dans la palette. Si Aucun, la valeur par défaut dépendra de la façon dont la palette est spécifiée. Par défaut, la valeur den_colors est de 6 couleurs.
2	desat Proportion pour désaturer chaque couleur.

Revenir

Return fait référence à la liste des tuples RVB. Voici les palettes Seaborn facilement disponibles -

Deep
Muted
Bright
Pastel
Dark
Colorblind

Outre ceux-ci, on peut également générer une nouvelle palette

Il est difficile de décider quelle palette utiliser pour un ensemble de données donné sans connaître les caractéristiques des données. En étant conscient, nous classerons les différentes manières d'utilisercolor_palette() types -

qualitative
sequential
diverging

Nous avons une autre fonction seaborn.palplot()qui traite des palettes de couleurs. Cette fonction trace la palette de couleurs sous forme de tableau horizontal. Nous en saurons plus surseaborn.palplot() dans les exemples à venir.

Palettes de couleurs qualitatives

Les palettes qualitatives ou catégorielles conviennent le mieux pour tracer les données catégorielles.

Exemple

from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(current_palette)
plt.show()

Production

Nous n'avons passé aucun paramètre dans color_palette();par défaut, nous voyons 6 couleurs. Vous pouvez voir le nombre de couleurs souhaité en passant une valeur aun_colorsparamètre. Ici lepalplot() est utilisé pour tracer le tableau de couleurs horizontalement.

Palettes de couleurs séquentielles

Les graphiques séquentiels conviennent pour exprimer la distribution de données allant de valeurs relativement faibles à des valeurs plus élevées dans une plage.

L'ajout d'un caractère supplémentaire «s» à la couleur passée au paramètre de couleur tracera le tracé séquentiel.

Exemple

from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette("Greens"))
plt.show()

Note −Nous devons ajouter «s» au paramètre comme «Verts» dans l'exemple ci-dessus.

Palette de couleurs divergentes

Les palettes divergentes utilisent deux couleurs différentes. Chaque couleur représente une variation de la valeur allant d'un point commun dans les deux sens.

Supposons de tracer les données comprises entre -1 et 1. Les valeurs de -1 à 0 prennent une couleur et 0 à +1 en prend une autre.

Par défaut, les valeurs sont centrées à partir de zéro. Vous pouvez le contrôler avec le centre des paramètres en passant une valeur.

Exemple

from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette("BrBG", 7))
plt.show()

Production

Définition de la palette de couleurs par défaut

Les fonctions color_palette() a un compagnon appelé set_palette()La relation entre eux est similaire aux paires couvertes dans le chapitre sur l'esthétique. Les arguments sont les mêmes pour les deuxset_palette() et color_palette(), mais les paramètres par défaut de Matplotlib sont modifiés pour que la palette soit utilisée pour tous les tracés.

Exemple

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
   x = np.linspace(0, 14, 100)
   for i in range(1, 5):
      plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)

import seaborn as sb
sb.set_style("white")
sb.set_palette("husl")
sinplot()
plt.show()

Production

Tracer une distribution univariée

La distribution des données est la chose la plus importante que nous devons comprendre lors de l'analyse des données. Ici, nous verrons comment seaborn nous aide à comprendre la distribution univariée des données.

Fonction distplot()fournit le moyen le plus pratique de jeter un coup d'œil rapide sur la distribution univariée. Cette fonction tracera un histogramme qui correspond à l'estimation de la densité du noyau des données.

Usage

seaborn.distplot()

Paramètres

Le tableau suivant répertorie les paramètres et leur description -

N ° Sr.	Paramètre et description
1	data Série, baie 1d ou liste
2	bins Spécification des bacs hist
3	hist booléen
4	kde booléen

Ce sont des paramètres fondamentaux et importants à examiner.

Les histogrammes représentent la distribution des données en formant des casiers le long de la plage des données, puis en dessinant des barres pour montrer le nombre d'observations qui tombent dans chaque casier.

Seaborn est livré avec quelques jeux de données et nous avons utilisé peu de jeux de données dans nos chapitres précédents. Nous avons appris à charger l'ensemble de données et à rechercher la liste des ensembles de données disponibles.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'],kde = False)
plt.show()

Production

Ici, kdel'indicateur est défini sur False. En conséquence, la représentation du tracé d'estimation du noyau sera supprimée et seul l'histogramme sera tracé.

L'estimation de densité de noyau (KDE) est un moyen d'estimer la fonction de densité de probabilité d'une variable aléatoire continue. Il est utilisé pour l'analyse non paramétrique.

Réglage du hist flag à False in distplot donnera le tracé d'estimation de la densité du noyau.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'],hist=False)
plt.show()

Production

Ajustement de la distribution paramétrique

distplot() est utilisé pour visualiser la distribution paramétrique d'un jeu de données.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'])
plt.show()

Production

Tracé de la distribution bivariée

La distribution bivariée est utilisée pour déterminer la relation entre deux variables. Cela concerne principalement la relation entre deux variables et la façon dont une variable se comporte par rapport à l'autre.

La meilleure façon d'analyser la distribution bivariée dans seaborn est d'utiliser le jointplot() fonction.

Jointplot crée une figure multi-panneaux qui projette la relation bivariée entre deux variables ainsi que la distribution univariée de chaque variable sur des axes séparés.

Nuage de points

Le nuage de points est le moyen le plus pratique de visualiser la distribution où chaque observation est représentée dans un tracé bidimensionnel via les axes x et y.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df)
plt.show()

Production

La figure ci-dessus montre la relation entre les petal_length et petal_widthdans les données Iris. Une tendance dans le graphique indique qu'il existe une corrélation positive entre les variables à l'étude.

Tracé Hexbin

Le regroupement hexagonal est utilisé dans l'analyse de données bivariées lorsque la densité des données est clairsemée, c'est-à-dire lorsque les données sont très dispersées et difficiles à analyser à travers des nuages de points.

Un paramètre d'addition appelé «kind» et une valeur «hex» trace le tracé hexbin.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df,kind = 'hex')
plt.show()

Estimation de la densité du noyau

L'estimation de la densité par noyau est une manière non paramétrique d'estimer la distribution d'une variable. Dans seaborn, nous pouvons tracer un kde en utilisantjointplot().

Passez la valeur 'kde' au paramètre kind pour tracer le tracé du noyau.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df,kind = 'hex')
plt.show()

Production

Les ensembles de données étudiés en temps réel contiennent de nombreuses variables. Dans de tels cas, la relation entre chaque variable doit être analysée. Tracer une distribution bivariée pour (n, 2) combinaisons sera un processus très complexe et prenant du temps.

Pour tracer plusieurs distributions bivariées par paires dans un jeu de données, vous pouvez utiliser pairplot()fonction. Cela montre la relation pour (n, 2) combinaison de variable dans un DataFrame sous forme de matrice de tracés et les tracés diagonaux sont les tracés univariés.

Haches

Dans cette section, nous allons apprendre ce que sont les axes, leur utilisation, leurs paramètres, etc.

Usage

seaborn.pairplot(data,…)

Paramètres

Le tableau suivant répertorie les paramètres des axes -

N ° Sr.	Paramètre et description
1	data Trame de données
2	hue Variable dans les données pour mapper les aspects du tracé à différentes couleurs.
3	palette Ensemble de couleurs pour mapper la variable de teinte
4	kind Genre d'intrigue pour les relations non identitaires. {'scatter', 'reg'}
5	diag_kind Type de tracé pour les sous-tracés diagonaux. {'hist', 'kde'}

À l'exception des données, tous les autres paramètres sont facultatifs. Il y a peu d'autres paramètres quipairplotPeut accepter. Les paramètres mentionnés ci-dessus sont souvent utilisés.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.set_style("ticks")
sb.pairplot(df,hue = 'species',diag_kind = "kde",kind = "scatter",palette = "husl")
plt.show()

Production

Nous pouvons observer les variations dans chaque parcelle. Les tracés sont au format matriciel où le nom de ligne représente l'axe x et le nom de colonne représente l'axe y.

Les tracés diagonaux sont des tracés de densité de noyau où les autres tracés sont des diagrammes de dispersion comme mentionné.

Dans nos chapitres précédents, nous avons découvert les nuages de points, les graphiques hexbin et les graphiques kde qui sont utilisés pour analyser les variables continues étudiées. Ces graphiques ne conviennent pas lorsque la variable à l'étude est catégorique.

Quand une ou les deux variables à l'étude sont catégoriques, nous utilisons des graphiques comme striplot (), swarmplot (), etc. Seaborn fournit une interface pour ce faire.

Nuage de points catégoriels

Dans cette section, nous en apprendrons davantage sur les nuages de points catégoriels.

stripplot ()

stripplot () est utilisé lorsque l'une des variables étudiées est catégorique. Il représente les données dans l'ordre trié le long de l'un des axes.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.stripplot(x = "species", y = "petal_length", data = df)
plt.show()

Production

Dans le graphique ci-dessus, nous pouvons clairement voir la différence de petal_lengthdans chaque espèce. Mais le problème majeur avec le nuage de points ci-dessus est que les points du nuage de points se chevauchent. Nous utilisons le paramètre 'Jitter' pour gérer ce type de scénario.

Jitter ajoute du bruit aléatoire aux données. Ce paramètre ajustera les positions le long de l'axe des catégories.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.stripplot(x = "species", y = "petal_length", data = df, jitter = Ture)
plt.show()

Production

Désormais, la répartition des points est facilement visible.

Parcelle d'essaim ()

Une autre option qui peut être utilisée comme alternative à 'Jitter' est la fonction swarmplot(). Cette fonction positionne chaque point du nuage de points sur l'axe catégoriel et évite ainsi le chevauchement des points -

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.swarmplot(x = "species", y = "petal_length", data = df)
plt.show()

Production

Dans les nuages de points catégoriels que nous avons traités dans le chapitre précédent, l'approche devient limitée dans les informations qu'elle peut fournir sur la distribution des valeurs au sein de chaque catégorie. Maintenant, en allant plus loin, voyons ce qui peut nous faciliter la comparaison avec les catégories.

Boîtes à moustaches

Boxplot est un moyen pratique de visualiser la distribution des données à travers leurs quartiles.

Les boîtes à moustaches ont généralement des lignes verticales s'étendant des boîtes qui sont appelées moustaches. Ces moustaches indiquent une variabilité en dehors des quartiles supérieur et inférieur, c'est pourquoi les boîtes à moustaches sont également appeléesbox-and-whisker intrigue et box-and-whisker diagramme. Toutes les valeurs aberrantes dans les données sont tracées sous forme de points individuels.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.swarmplot(x = "species", y = "petal_length", data = df)
plt.show()

Production

Les points sur le graphique indiquent la valeur aberrante.

Parcelles de violon

Les graphiques de violon sont une combinaison de la boîte à moustaches et des estimations de densité du noyau. Ainsi, ces graphiques sont plus faciles à analyser et à comprendre la distribution des données.

Utilisons l'ensemble de données de conseils appelé pour en savoir plus sur les parcelles de violon. Cet ensemble de données contient les informations relatives aux pourboires donnés par les clients d'un restaurant.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y = "total_bill", data=df)
plt.show()

Production

Les valeurs de quartile et de moustache de la boîte à moustaches sont affichées à l'intérieur du violon. Comme l'intrigue du violon utilise KDE, la partie la plus large du violon indique la densité la plus élevée et la région étroite représente une densité relativement plus faible. La gamme Inter-Quartile en boxplot et la portion de densité plus élevée en kde tombent dans la même région de chaque catégorie de violon plot.

Le graphique ci-dessus montre la distribution de total_bill sur quatre jours de la semaine. Mais, en plus de cela, si nous voulons voir comment la distribution se comporte par rapport au sexe, explorons-la dans l'exemple ci-dessous.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y = "total_bill",hue = 'sex', data = df)
plt.show()

Production

Maintenant, nous pouvons clairement voir le comportement de dépenses entre les hommes et les femmes. On peut facilement dire que les hommes font plus de factures que les femmes en regardant l'intrigue.

Et, si la variable de teinte n'a que deux classes, nous pouvons embellir l'intrigue en divisant chaque violon en deux au lieu de deux violons un jour donné. Les deux parties du violon se réfèrent à chaque classe dans la variable de teinte.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y="total_bill",hue = 'sex', data = df)
plt.show()

Production

Dans la plupart des situations, nous traitons des estimations de l'ensemble de la distribution des données. Mais quand il s'agit d'estimer la tendance centrale, nous avons besoin d'une manière spécifique de résumer la distribution. La moyenne et la médiane sont les techniques très souvent utilisées pour estimer la tendance centrale de la distribution.

Dans toutes les parcelles que nous avons apprises dans la section ci-dessus, nous avons fait la visualisation de l'ensemble de la distribution. Parlons maintenant des parcelles avec lesquelles nous pouvons estimer la tendance centrale de la distribution.

Bar Plot

le barplot()montre la relation entre une variable catégorielle et une variable continue. Les données sont représentées dans des barres rectangulaires où la longueur de la barre représente la proportion des données dans cette catégorie.

Le graphique à barres représente l'estimation de la tendance centrale. Utilisons le jeu de données «titanesque» pour apprendre les graphiques à barres.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.barplot(x = "sex", y = "survived", hue = "class", data = df)
plt.show()

Production

Dans l'exemple ci-dessus, nous pouvons voir que le nombre moyen de survivances des hommes et des femmes dans chaque classe. À partir de l'intrigue, nous pouvons comprendre que plus de femmes ont survécu que d'hommes. Chez les hommes et les femmes, un plus grand nombre de survivants proviennent de la première classe.

Un cas particulier dans le barplot est de montrer le nombre d'observations dans chaque catégorie plutôt que de calculer une statistique pour une deuxième variable. Pour cela, nous utilisonscountplot().

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.countplot(x = " class ", data = df, palette = "Blues");
plt.show()

Production

Plot dit que, le nombre de passagers dans la troisième classe est plus élevé que dans la première et la deuxième classe.

Tracés de points

Les tracés de points servent de même que les tracés à barres mais dans un style différent. Plutôt que la barre entière, la valeur de l'estimation est représentée par le point à une certaine hauteur sur l'autre axe.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.pointplot(x = "sex", y = "survived", hue = "class", data = df)
plt.show()

Production

Il est toujours préférable d'utiliser des ensembles de données «depuis longtemps» ou «rangés». Mais parfois, lorsque nous n'avons aucune option plutôt que d'utiliser un ensemble de données «grand format», les mêmes fonctions peuvent également être appliquées aux données «grand format» dans une variété de formats, y compris les cadres de données Pandas ou NumPy bidimensionnel tableaux. Ces objets doivent être passés directement au paramètre de données les variables x et y doivent être spécifiées sous forme de chaînes

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.boxplot(data = df, orient = "h")
plt.show()

Production

De plus, ces fonctions acceptent des vecteurs d'objets Pandas ou NumPy plutôt que des variables dans un DataFrame.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.boxplot(data = df, orient = "h")
plt.show()

Production

Le principal avantage de l'utilisation de Seaborn pour de nombreux développeurs dans le monde Python est qu'il peut prendre l'objet pandas DataFrame comme paramètre.

Les données catégorielles peuvent-elles être visualisées à l'aide de deux graphiques, vous pouvez soit utiliser les fonctions pointplot(), ou la fonction de niveau supérieur factorplot().

Factorplot

Factorplot dessine un tracé catégoriel sur un FacetGrid. En utilisant le paramètre «kind», nous pouvons choisir l'intrigue comme boxplot, violinplot, barplot et stripplot. FacetGrid utilise le pointplot par défaut.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = pulse", hue = "kind",data = df);
plt.show()

Production

Nous pouvons utiliser différents graphiques pour visualiser les mêmes données en utilisant le kind paramètre.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = "pulse", hue = "kind", kind = 'violin',data = df);
plt.show()

Production

Dans factorplot, les données sont tracées sur une grille à facettes.

Qu'est-ce que Facet Grid?

Facet grid forme une matrice de panneaux définis par ligne et colonne en divisant les variables. En raison des panneaux, une seule parcelle ressemble à plusieurs parcelles. Il est très utile d'analyser toutes les combinaisons de deux variables discrètes.

Visualisons la définition ci-dessus avec un exemple

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = "pulse", hue = "kind", kind = 'violin', col = "diet", data = df);
plt.show()

Production

L'avantage d'utiliser Facet est que nous pouvons entrer une autre variable dans le graphique. Le graphique ci-dessus est divisé en deux graphiques basés sur une troisième variable appelée «régime» utilisant le paramètre «col».

Nous pouvons créer de nombreuses facettes de colonne et les aligner avec les lignes de la grille -

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.factorplot("alive", col = "deck", col_wrap = 3,data = df[df.deck.notnull()],kind = "count")
plt.show()

production

La plupart du temps, nous utilisons des ensembles de données contenant plusieurs variables quantitatives, et le but d'une analyse est souvent de relier ces variables entre elles. Cela peut être fait à travers les lignes de régression.

Lors de la construction des modèles de régression, nous vérifions souvent multicollinearity,où nous devions voir la corrélation entre toutes les combinaisons de variables continues et prendrons les mesures nécessaires pour supprimer la multicolinéarité si elle existe. Dans de tels cas, les techniques suivantes sont utiles.

Fonctions pour dessiner des modèles de régression linéaire

Il existe deux fonctions principales dans Seaborn pour visualiser une relation linéaire déterminée par régression. Ces fonctions sontregplot() et lmplot().

regplot vs lmplot

regplot	lmplot
accepte les variables x et y dans une variété de formats, y compris des tableaux numpy simples, des objets de la série pandas ou comme références à des variables dans un DataFrame pandas	a des données comme paramètre obligatoire et les variables x et y doivent être spécifiées sous forme de chaînes. Ce format de données est appelé données «longues»

Tirons maintenant les graphiques.

Exemple

Tracer le regplot puis lmplot avec les mêmes données dans cet exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.regplot(x = "total_bill", y = "tip", data = df)
sb.lmplot(x = "total_bill", y = "tip", data = df)
plt.show()

Production

Vous pouvez voir la différence de taille entre deux parcelles.

Nous pouvons également ajuster une régression linéaire lorsque l'une des variables prend des valeurs discrètes

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.lmplot(x = "size", y = "tip", data = df)
plt.show()

Production

Montage de différents types de modèles

Le modèle de régression linéaire simple utilisé ci-dessus est très simple à ajuster, mais dans la plupart des cas, les données ne sont pas linéaires et les méthodes ci-dessus ne peuvent pas généraliser la droite de régression.

Utilisons le jeu de données d'Anscombe avec les graphiques de régression -

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x="x", y="y", data=df.query("dataset == 'I'"))
plt.show()

Dans ce cas, les données correspondent bien au modèle de régression linéaire avec moins de variance.

Voyons un autre exemple où les données prennent un écart élevé, ce qui montre que la ligne de meilleur ajustement n'est pas bonne.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x = "x", y = "y", data = df.query("dataset == 'II'"))
plt.show()

Production

Le graphique montre l'écart élevé des points de données par rapport à la droite de régression. Un tel ordre supérieur non linéaire peut être visualisé en utilisant lelmplot() et regplot()Ils peuvent s'adapter à un modèle de régression polynomiale pour explorer des types simples de tendances non linéaires dans l'ensemble de données -

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x = "x", y = "y", data = df.query("dataset == 'II'"),order = 2)
plt.show()

Production

Une approche utile pour explorer des données de dimension moyenne consiste à dessiner plusieurs instances du même graphique sur différents sous-ensembles de votre ensemble de données.

Cette technique est communément appelée «tracé en treillis» ou «trellis», et elle est liée à l'idée de «petits multiples».

Pour utiliser ces fonctionnalités, vos données doivent se trouver dans un Pandas DataFrame.

Tracer de petits multiples de sous-ensembles de données

Dans le chapitre précédent, nous avons vu l'exemple FacetGrid où la classe FacetGrid aide à visualiser la distribution d'une variable ainsi que la relation entre plusieurs variables séparément dans des sous-ensembles de votre ensemble de données à l'aide de plusieurs panneaux.

Un FacetGrid peut être dessiné avec jusqu'à trois dimensions - ligne, col et teinte. Les deux premiers ont une correspondance évidente avec le tableau d'axes résultant; considérez la variable de teinte comme une troisième dimension le long d'un axe de profondeur, où différents niveaux sont tracés avec différentes couleurs.

FacetGrid object prend un dataframe comme entrée et les noms des variables qui formeront les dimensions de ligne, de colonne ou de teinte de la grille.

Les variables doivent être catégoriques et les données à chaque niveau de la variable seront utilisées pour une facette le long de cet axe.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "time")
plt.show()

Production

Dans l'exemple ci-dessus, nous venons d'initialiser le facetgrid objet qui ne dessine rien sur eux.

La principale approche pour visualiser les données sur cette grille consiste à FacetGrid.map()méthode. Regardons la distribution des pointes dans chacun de ces sous-ensembles, à l'aide d'un histogramme.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "time")
g.map(plt.hist, "tip")
plt.show()

Production

Le nombre de tracés est supérieur à un en raison du paramètre col. Nous avons discuté du paramètre col dans nos chapitres précédents.

Pour créer un tracé relationnel, transmettez les noms de variables multiples.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "sex", hue = "smoker")
g.map(plt.scatter, "total_bill", "tip")
plt.show()

Production

PairGrid nous permet de dessiner une grille de sous-tracés en utilisant le même type de tracé pour visualiser les données.

Contrairement à FacetGrid, il utilise différentes paires de variables pour chaque sous-tracé. Il forme une matrice de sous-parcelles. Elle est aussi parfois appelée «matrice de nuage de points».

L'utilisation de pairgrid est similaire à facetgrid. Initialisez d'abord la grille, puis passez la fonction de traçage.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map(plt.scatter);
plt.show()

Il est également possible de tracer une fonction différente sur la diagonale pour montrer la distribution univariée de la variable dans chaque colonne.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()

Production

Nous pouvons personnaliser la couleur de ces graphiques en utilisant une autre variable catégorielle. Par exemple, l'ensemble de données sur l'iris comporte quatre mesures pour chacune des trois espèces différentes de fleurs d'iris afin que vous puissiez voir en quoi elles diffèrent.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()

Production

Nous pouvons utiliser une fonction différente dans les triangles supérieur et inférieur pour voir différents aspects de la relation.

Exemple

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_upper(plt.scatter)
g.map_lower(sb.kdeplot, cmap = "Blues_d")
g.map_diag(sb.kdeplot, lw = 3, legend = False);
plt.show()

Production