Visualiser les données avec plotnine – Real Python

Les données: la source de l'information

Lorsque vous créez une visualisation de données, la première étape consiste à spécifier les données à tracer. Dans plotnine, vous faites cela en créant un ggplot objet et en transmettant l'ensemble de données que vous souhaitez utiliser au constructeur.

Le code suivant crée un ggplot objet utilisant le jeu de données d'exemple d'économie de carburant de plotnine, mpg:

de plotnine.data importer mpg
de plotnine importer ggplot

ggplot(mpg)

Ce code crée un objet appartenant à la classe ggplot en utilisant le mpg base de données. Notez que puisque vous n’avez pas encore spécifié l’esthétique ou l’objet géométrique, le code ci-dessus générera un tracé vide. Ensuite, vous construirez l'intrigue pièce par pièce.

Comme vous l'avez vu précédemment, vous pouvez inspecter l'ensemble de données de Jupyter Notebook avec le code suivant:

de plotnine.data importer mpg

mpg

Ces deux lignes de code importent et affichent l'ensemble de données, affichant la sortie suivante:

        fabricant modèle année cylindrique cylindre trans drv cty hwy classe fl
0 audi a4 1.8 1999 4 auto (l5) f 18 29 p compacte
1 audi a4 1.8 1999 4 manuelle (m5) f 21 29 p compacte
2 audi a4 2.0 2008 4 manuel (m6) f 20 31 p compact
...

La sortie est un tableau contenant les données de consommation de carburant pour 234 voitures de 1999 à 2008. Le déplacement (dépl) est la taille du moteur en litres. cty et autoroute sont la consommation de carburant en miles par gallon pour la conduite en ville et sur autoroute.

Dans les sections suivantes, vous apprendrez les étapes pour transformer ces données brutes en graphiques à l’aide de plotnine.

Esthétique: définir des variables pour chaque axe

Après avoir spécifié les données que vous souhaitez visualiser, l'étape suivante consiste à définir la variable que vous souhaitez utiliser pour chaque axe de votre tracé. Chaque ligne d'un DataFrame peut contenir de nombreux champs, vous devez donc indiquer à plotnine les variables que vous souhaitez utiliser dans le graphique.

L'esthétique associe les variables de données aux attributs graphiques, comme la position 2D et la couleur. Par exemple, le code suivant crée un graphique qui montre les classes de véhicules sur l'axe des x et la consommation de carburant sur l'autoroute sur l'axe des y:

de plotnine.data importer mpg
de plotnine importer ggplot, aes

ggplot(mpg) + aes(X="classe", y="hwy")

En utilisant le ggplot objet de la section précédente comme base de la visualisation, le code cartographie le véhicule classe attribut à l'axe graphique horizontal et au autoroute économie de carburant sur l'axe vertical.

Mais le tracé généré est toujours vide car il manque l’objet géométrique pour représenter chaque élément de données.

Objets géométriques: choisissez différents types de tracé

Après avoir défini vos données et les attributs que vous souhaitez utiliser dans le graphique, vous devez spécifier un objet géométrique pour indiquer à plotnine comment les points de données doivent être dessinés.

plotnine fournit de nombreux objets géométriques que vous pouvez utiliser prêts à l'emploi, tels que des lignes, des points, des barres, des polygones et bien plus encore. Une liste de tous les objets géométriques disponibles est disponible dans plotnine's geoms Référence API.

Le code suivant montre comment utiliser l'objet géométrique ponctuel pour tracer des données:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_point

ggplot(mpg) + aes(X="classe", y="hwy") + geom_point()

Dans le code ci-dessus, geom_point () sélectionne l'objet géométrique ponctuel. L'exécution du code produit la sortie suivante:

Comme vous pouvez le voir, la visualisation des données générées a un point pour chaque véhicule de l'ensemble de données. Les axes indiquent la classe du véhicule et la consommation de carburant sur autoroute.

Il existe de nombreux autres objets géométriques que vous pouvez utiliser pour visualiser le même jeu de données. Par exemple, le code suivant utilise l'objet géométrique bar pour afficher le nombre de véhicules pour chaque classe:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_bar

ggplot(mpg) + aes(X="classe") + geom_bar()

Ici, geom_bar () définit l'objet géométrique sur bar. Étant donné que le code ne spécifie aucun attribut pour l'axe des y, geom_bar () regroupe implicitement les points de données par l'attribut utilisé pour l'axe des x, puis utilise le nombre de points dans chaque groupe pour l'axe des y.

En exécutant le code, vous verrez le résultat suivant:

La hauteur de chaque barre du graphique représente le nombre de véhicules appartenant à la classe de véhicules correspondante. Vous en apprendrez plus sur l'agrégation de données et le regroupement de ces dernières sections.

Dans cette section, vous avez découvert les trois composants obligatoires qui doivent être spécifiés lors de la création de visualisations de données:

1. Les données
2. Esthétique
3. Objets géométriques

Vous avez également appris à les combiner en utilisant le + opérateur.

Dans les sections suivantes, vous découvrirez certains composants facultatifs que vous pouvez utiliser pour créer des graphiques plus complexes et plus beaux.

Transformations statistiques: agrégez et transformez vos données

Les transformations statistiques appliquent un certain calcul aux données avant de les tracer, par exemple pour afficher un indicateur statistique au lieu des données brutes. plotnine comprend plusieurs transformations statistiques que vous pouvez utiliser.

Disons que vous souhaitez créer un histogramme pour afficher les distributions des niveaux du lac Huron de 1875 à 1975. Cet ensemble de données est inclus avec plotnine. Vous pouvez utiliser le code suivant pour inspecter l'ensemble de données de Jupyter Notebook et en savoir plus sur son format:

# Importez notre exemple de jeu de données avec les niveaux du lac Huron 1875–1975
de plotnine.data importer huron

huron

Le code importe et affiche l'ensemble de données, produisant la sortie suivante:

                niveau de l'année décennie
0 1875 580,38 1870
1 1876 581,86 1870
...
96 1971 579,89 1970
97 1972 579,96 1970

Comme vous pouvez le voir, l'ensemble de données contient trois colonnes:

1. année
2. niveau
3. décennie

Vous pouvez maintenant créer l'histogramme en deux étapes:

1. Regroupez les mesures de niveau dans des bacs.
2. Affichez le nombre de mesures dans chaque bac à l'aide d'un diagramme à barres.

Le code suivant montre comment ces étapes peuvent être effectuées dans plotnine:

de plotnine.data importer huron
de plotnine importer ggplot, aes, stat_bin, geom_bar

ggplot(huron) + aes(X="niveau") + stat_bin(bacs=dix) + geom_bar()

Dans le code ci-dessus, stat_bin () divise le niveau gamme dans dix bacs de taille égale. Ensuite, le nombre de mesures qui tombe dans chaque case est dessiné à l'aide d'un diagramme à barres.

L'exécution du code produit le graphique suivant:

Ce graphique montre le nombre de mesures pour chaque gamme de niveaux de lac. Comme vous pouvez le voir, la plupart du temps, le niveau se situait entre 578 et 580.

Pour les tâches les plus courantes, comme la création d'histogrammes, plotnine inclut des fonctions très pratiques qui rendent le code plus concis. Par exemple, avec geom_histogram (), vous pouvez construire l'histogramme ci-dessus comme ceci:

de plotnine.data importer huron
de plotnine importer ggplot, aes, geom_histogram

ggplot(huron) + aes(X="niveau") + geom_histogram(bacs=dix)

En utilisant geom_histogram () revient à utiliser stats_bin () et alors geom_bar (). L'exécution de ce code génère le même graphique que vous avez vu ci-dessus.

Voyons maintenant un autre exemple de transformation statistique. UNE boîte à moustaches est un outil statistique très populaire utilisé pour afficher le minimum, le maximum, la médiane de l'échantillon, les premier et troisième quartiles et les valeurs aberrantes d'un ensemble de données.

Supposons que vous souhaitiez créer une visualisation basée sur le même jeu de données pour afficher une boîte à moustaches pour les mesures de niveau de chaque décennie. Vous pouvez construire ce graphique en deux étapes:

1. Regroupez les mesures par décennie.
2. Créez une boîte à moustaches pour chaque groupe.

Vous pouvez faire la première étape en utilisant facteur() dans la spécification esthétique. facteur() regroupe tous les points de données qui partagent la même valeur pour l'attribut spécifié.

Ensuite, une fois que vous avez regroupé les données par décennie, vous pouvez dessiner une boîte à moustaches pour chaque groupe en utilisant geom_boxplot ().

Le code suivant crée un tracé en suivant les étapes décrites ci-dessus:

de plotnine.data importer huron
de plotnine importer ggplot, aes, geom_boxplot

(
  ggplot(huron)
  + aes(X="facteur (décennie)", y="niveau")
  + geom_boxplot()
)

Le code regroupe les lignes de données par décennie en utilisant facteur() puis utilise geom_boxplot () pour créer les boîtes à moustaches.

Comme vous l'avez vu dans l'exemple précédent, certains objets géométriques ont des transformations statistiques implicites. C'est vraiment pratique car cela rend votre code plus concis. En utilisant geom_boxplot () implique stat_boxplot (), qui prend en charge le calcul des quartiles et des valeurs aberrantes.

En exécutant le code ci-dessus, vous obtiendrez le graphique suivant:

Le graphique montre les distributions des niveaux d'eau à l'aide d'une boîte à moustaches pour chaque décennie.

Il existe d'autres transformations statistiques que vous pouvez utiliser pour créer des visualisations de données à l'aide de ggplot en Python. Vous pouvez en apprendre davantage à leur sujet dans la documentation de l'API stats de plotnine.

Échelles: changer l'échelle des données en fonction de sa signification

Les échelles sont un autre type de transformation que vous pouvez appliquer lors du mappage des données à l'esthétique. Ils peuvent aider à rendre vos visualisations plus faciles à comprendre.

Au début de ce didacticiel, vous avez vu un graphique montrant la population de chaque année depuis 1970. Le code suivant montre comment vous pouvez utiliser des échelles pour afficher les années écoulées depuis 1970 au lieu des dates brutes:

de plotnine.data importer économie
de plotnine importer ggplot, aes, scale_x_timedelta, laboratoires, geom_line

(
    ggplot(économie)
    + aes(X="Date", y="pop")
    + scale_x_timedelta(Nom="Années depuis 1970")
    + laboratoires(Titre=«Évolution de la population», y="Population")
    + geom_line()
)

En utilisant scale_x_timedelta () transforme la valeur x de chaque point en calculant sa différence par rapport à la date la plus ancienne de l'ensemble de données. Notez que le code utilise également laboratoires () pour définir une étiquette plus descriptive sur l'axe des y et le titre.

L'exécution du code montre ce tracé:

Sans modifier les données, vous avez rendu la visualisation plus facile à comprendre et plus conviviale pour le lecteur. Comme vous pouvez le voir, le graphique a maintenant de meilleures descriptions et l'axe des x montre les années écoulées depuis 1970 au lieu des dates.

plotnine fournit un grand nombre de transformations d'échelle parmi lesquelles vous pouvez choisir, y compris des échelles logarithmiques et d'autres échelles non linéaires. Vous pouvez en apprendre davantage à leur sujet dans la référence API des balances de plotnine.

Systèmes de coordonnées: mapper des valeurs de données à un espace 2D

Un système de coordonnées définit la manière dont les points de données sont mappés aux emplacements graphiques 2D dans le tracé. Vous pouvez le considérer comme une carte des variables mathématiques aux positions graphiques. Le choix du bon système de coordonnées peut améliorer la lisibilité de vos visualisations de données.

Reprenons l'exemple précédent du graphique à barres pour compter les véhicules appartenant à différentes classes. Vous avez créé le tracé à l'aide du code suivant:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_bar

ggplot(mpg) + aes(X="classe") + geom_bar()

Le code utilise geom_bar () pour dessiner une barre pour chaque classe de véhicule. Puisqu'aucun système de coordonnées particulier n'est défini, celui par défaut est utilisé.

L'exécution du code génère le tracé suivant:

La hauteur de chaque barre du graphique représente le nombre de véhicules dans une classe.

Bien qu'il n'y ait rien de mal avec le graphique ci-dessus, les mêmes informations pourraient être mieux visualisées en inversant les axes pour afficher des barres horizontales au lieu de verticales.

plotnine fournit plusieurs fonctions qui vous permettent de modifier le système de coordonnées. Vous pouvez inverser les axes en utilisant coord_flip ():

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_bar, coord_flip

ggplot(mpg) + aes(X="classe") + geom_bar() + coord_flip()

Le code inverse les axes x et y en utilisant coord_flip (). En exécutant le code, vous verrez le graphique suivant:

Ce graphique montre les mêmes informations que vous avez vues dans le graphique précédent, mais en inversant les axes, vous trouverez peut-être plus facile de comprendre et de comparer différentes barres.

Il n’existe pas de règle absolue sur le meilleur système de coordonnées. Vous devez choisir celui qui convient le mieux à votre problème et à vos données. Essayez-les et faites des expériences pour savoir ce qui fonctionne pour chaque cas. Vous pouvez trouver plus d'informations sur les autres systèmes de coordonnées dans la référence API de coordonnées de plotnine.

Facettes: tracer des sous-ensembles de données dans des panneaux dans le même tracé

Dans cette section, vous allez découvrir facettes, l'une des fonctionnalités les plus intéressantes de plotnine. Les facettes vous permettent de regrouper les données selon certains attributs, puis de tracer chaque groupe individuellement, mais dans la même image. Ceci est particulièrement utile lorsque vous souhaitez afficher plus de deux variables dans le même graphique.

Par exemple, supposons que vous souhaitiez utiliser l'ensemble de données sur la consommation de carburant (mpg) et construisez un graphique montrant les miles par gallon pour chaque taille de moteur (déplacement) pour chaque classe de véhicule pour chaque année. Dans ce cas, votre tracé doit afficher les informations de quatre variables:

1. autoroute: Miles par gallon
2. déplaire: La taille du moteur
3. classe: Classe de véhicule
4. année: Année modèle

Cela présente un défi, car vous avez plus de variables que de dimensions graphiques. Vous pourriez utiliser une perspective 3D si vous deviez afficher trois variables, mais un graphique en quatre dimensions est difficile à imaginer.

Il existe une astuce en deux étapes que vous pouvez utiliser face à ce problème:

1. Commencez par partitionner les données en groupes où tous les points de données d'un groupe partagent les mêmes valeurs pour certains attributs.

2. Tracez chaque groupe individuellement, en affichant uniquement les attributs non utilisés dans le regroupement.

Pour revenir à l'exemple, vous pouvez regrouper les véhicules par classe et par année, puis tracer chaque groupe pour afficher le déplacement et les miles par gallon. La visualisation suivante a été générée à l'aide de cette technique:

Comme vous pouvez le voir dans le graphique ci-dessus, il y a un panneau pour chaque groupe. Chaque panneau montre les miles par gallon pour différents déplacements de moteur appartenant à cette classe de véhicule et à cette année.

Cette visualisation de données a été générée avec le code suivant:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, facet_grid, laboratoires, geom_point

(
    ggplot(mpg)
    + facet_grid(facettes="année ~ classe")
    + aes(X="dépl", y="hwy")
    + laboratoires(
        X="La taille du moteur",
        y="Miles par gallon",
        Titre="Miles par gallon pour chaque année et classe de véhicule",
    )
    + geom_point()
)

Le code partitionne les données par année et par classe de véhicule en utilisant facet_grid (), en lui passant les attributs à utiliser pour le partitionnement avec facettes = "année ~ classe". Pour chaque partition de données, le tracé est construit à l'aide des composants que vous avez vus dans les sections précédentes, comme l'esthétique, les objets géométriques et laboratoires ().

facet_grid () affiche les partitions dans une grille, en utilisant un attribut pour les lignes et l'autre pour les colonnes. plotnine fournit d'autres méthodes de facettage que vous pouvez utiliser pour partitionner vos données à l'aide de plus de deux attributs. Pour en savoir plus, consultez la référence API des facettes de plotnine.

Thèmes: améliorez l'apparence de votre visualisation

Un autre excellent moyen d'améliorer la présentation de vos visualisations de données consiste à choisir un thème autre que celui par défaut pour faire ressortir vos graphiques, les rendant plus beaux et plus dynamiques.

plotnine comprend plusieurs thèmes parmi lesquels vous pouvez choisir. Le code suivant génère le même graphique que celui que vous avez vu dans la section précédente, mais en utilisant le thème sombre:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, facet_grid, laboratoires, geom_point, theme_dark

(
    ggplot(mpg)
    + facet_grid(facettes="année ~ classe")
    + aes(X="dépl", y="hwy")
    + laboratoires(
        X="La taille du moteur",
        y="Miles par gallon",
        Titre="Miles par gallon pour chaque année et classe de véhicule",
    )
    + geom_point()
    + theme_dark()
)

Dans le code ci-dessus, en spécifiant theme_dark () dit à plotnine de dessiner l'intrigue en utilisant un thème sombre. Voici le graphique généré par ce code:

Comme vous pouvez le voir sur l'image, la définition du thème affecte les couleurs, les polices et les styles de formes.

theme_xkcd () est un autre thème qui mérite d'être mentionné car il vous donne un look de bande dessinée vraiment cool. Cela donne à vos visualisations de données l'apparence des bandes dessinées xkcd:

Choisir le bon thème peut vous aider à attirer et à retenir l'attention de votre public. Vous pouvez voir une liste des thèmes disponibles dans la référence API des thèmes de plotnine.

Dans les sections précédentes, vous avez découvert les aspects les plus importants des grammaires graphiques et comment utiliser plotnine pour créer des visualisations de données. En utilisant ggplot en Python vous permet de créer des visualisations progressivement, en vous concentrant d'abord sur vos données, puis en ajoutant et en ajustant des composants pour améliorer sa représentation graphique.

Dans la section suivante, vous apprendrez à utiliser les couleurs et à exporter vos visualisations.