PdVega-Beispiele

Importe

[1]:
import pandas as pd
import numpy as np
import pdvega

Deklarative Beschreibung der Datenvisualisierung

Mit Vega-Lite lässt sich deklarativ beschreiben, wie die Daten auf Visualisierungsfunktionen abgebildet werden sollen. Mit pdvega wird diese Spezifikation ähnlich einfach wie über die Matplotlib-API verfügbar: data.plot muss lediglich durch data.vgplot ersetzt werden, wobei sich data auf Pandas-Series oder DataFrame-Objekte bezieht.

Laden eines DataFrame mit Zeitreihen von Aktienkursen:

[2]:
from vega_datasets import data
stocks = data.stocks(pivoted=True)

Matplotlib-API:

[3]:
stocks.plot.line()
[3]:
<matplotlib.axes._subplots.AxesSubplot at 0x7ff5c92cf390>
../../_images/vega_pdvega_examples_7_1.png

pdvega-API:

[5]:
stocks.vgplot.line()
../../_images/vega_pdvega_examples_9_2.png

Das Ergebnis sind schöne Datenvisualisierungen mit einem Minimum an Boilerplate. Zudem sind die aus pdvega erstellten Diagramme interaktiv und lassen sich Verschieben und Vergrößern/Verkleinern.

Einfache Datenvisualisierungen mit data.vgplot

Die zentrale Schnittstelle von pdvega ist das vgplot-Attribut, das Pandas-DataFrame und Series-Objekten hinzugefügt wird.

Wie bei dem Pandas Plots gibt es zwei Möglichkeiten, Diagramme zu erstellen:

  1. das vgplot-Attribut eines Pandas-Objekts kann direkt aufgerufen werden, also z.B.

iris.vgplot(kind='scatter', x='sepalLength', y='petalLength', c='species')
  1. Alternativ kann auch die spezifische Methode aufgerufen werden, die jedem Diagrammtyp zugeordnet ist:

iris.vgplot.scatter(x='sepalLength', y='petalLength', c='species')

Dieser Ansatz bietet den Vorteil, dass verfügbare Plottypen über die Tabulatorvervollständigung untersucht werden können. Die einzelnen Funktionen bieten auch eine detailliertere Dokumentation der für jede Methode verfügbaren Argumente.

Diagrammtypen

Die vgplot-API stellt neun grundlegende Diagrammtypen bereit:

Liniendiagramme mit vgplot.line

Der Standarddiagrammtyp für vgplot ist ein Liniendiagramm.

Sofern nichts anders angegeben ist, wird der Index von DataFrame oder Series als x-Achsenvariable verwendet, und eine separate Linie für die y-Werte jeder Spalte des DataFrame. Wenn Sie ihr nur eine Teilmenge der Spalten plotten lassen möchtet, könnt ihr mithilfe der Pandas-Indizierung die Spalten auswählen, an denen ihr interessiert seid:

[6]:
stocks[['AAPL', 'AMZN']].vgplot.line()
../../_images/vega_pdvega_examples_14_2.png

Liniendiagramme können weiter angepasst werden. Informationen hierzu findet ihr in der Dokumentation:

Streudiagramme mit vgplot.scatter

[7]:
stocks.vgplot.scatter(x='AAPL', y='AMZN')
../../_images/vega_pdvega_examples_17_2.png

Um Streudiagramme weiter anzupassen, schaut euch pdvega.FramePlotMethods.scatter() an.

Flächendiagramme mit vgplot.area

[8]:
stocks[['MSFT', 'AAPL', 'AMZN']].vgplot.area()
../../_images/vega_pdvega_examples_20_2.png

Flächendiagramme können auch gestapelt werden. In diesem Fall sind transparente Flächen häufig hilfreich.

[9]:
stocks[['MSFT', 'AAPL', 'AMZN']].vgplot.area(stacked=False, alpha=0.4)
../../_images/vega_pdvega_examples_22_2.png

Flächendiagramme können weiter angepasst werden, siehe

Balkendiagramme mit vgplot.bar

[10]:
np.random.seed(1234)
df = pd.DataFrame(np.random.rand(10, 2), columns=['a', 'b'])

df.vgplot.bar()
../../_images/vega_pdvega_examples_25_2.png

Wie bei Flächendiagrammen könnt ihr mit stacked=True die Balken stapeln:

[11]:
df.vgplot.bar(stacked=True)
../../_images/vega_pdvega_examples_27_2.png

Darüberhinaus können horizontale Balkendiagramme erstellt werden mit barh:

[12]:
df.vgplot.barh(stacked=True)
../../_images/vega_pdvega_examples_29_2.png

Histogramme mit vgplot.hist

[13]:
df = pd.DataFrame({'a': np.random.randn(1000) + 1,
                   'b': np.random.randn(1000),
                   'c': np.random.randn(1000) - 1},
                  columns=['a', 'b', 'c'])

df.vgplot.hist(bins=50, alpha=0.5)
../../_images/vega_pdvega_examples_31_2.png

Histogramme können weiter angepasst werden, siehe

Kerndichteschätzdiagramme mit vgplot.kde

Kerndichteschätzdiagramme (englisch kernel density estimation, KDE) erzeugen ähnlich wie Histogramme glatte Kurven, die die Dichte der Messpunkte angeben.

[14]:
df.vgplot.kde()
../../_images/vega_pdvega_examples_34_2.png

KDE-Diagramme können weiter angepasst werden mit

Heatmaps mit vgplot.heatmap

Pandas-Plotting hat eine Funktion zum Erstellen einer hexagonal-gruppierten Heatmap zweidimensionaler Daten. Leider unterstützt derzeit weder Vega noch Vega-Lite diese hexagonalen Heatmaps. Sie unterstützen jedoch kartesische Heatmaps,und diese Funktionalität ist auch enthalten in pdvega:

[15]:
df.vgplot.heatmap(x='a', y='b', C='c', gridsize=20)
../../_images/vega_pdvega_examples_37_2.png

Heatmap-Diagramme können weiter angepasst werden, siehe pdvega.FramePlotMethods.heatmap().

Statistische Visualisierung mit pdvega.plotting

pdvegaunterstützt auch viele der komplexeren Plot-Routinen, die im pandas.plotting-Submodul verfügbar sind. Im Folgenden zeigen wir das Beispieleiner Multi-Panel-Streudiagramm-Matrix aus Fisher’s Iris-Datensatz:

[16]:
iris = data.iris()
pdvega.scatter_matrix(iris, 'species', figsize=(7, 7))
../../_images/vega_pdvega_examples_40_2.png

In diesem Diagramm könnt ihr interaktiv Verschieben und Verkleinern/Vergrößern. Mit gedrückter Umschalttaste könnt ihr auch einzelne Messpunkte auswählen.

Parallele Koordinaten

Eine andere Möglichkeit, mehrdimensionale Daten zu visualisieren, besteht darin, jede Dimension unabhängig voneinander mithilfe eines Diagramms mit parallelen Koordinaten zu betrachten. Dies kann mit pdvega.parallel_coordinates() realisiert werden, wobei die API pandas.plotting.parallel_coordinates() entspricht:

[17]:
pdvega.parallel_coordinates(iris, "species")
../../_images/vega_pdvega_examples_43_2.png

Auf einen Blick könnt ihr Beziehungen zwischen Punkten erkennen und insbesondere deutlich machen, dass sich die „setosa“-Art in Breite und Länge der Blütenblätter deutlich von den beiden anderen Arten unterscheidet.

Andrews-Kurven

Ein ähnlicher Ansatz zur Visualisierung von Datendimensionen ist als Andrews-Kurve bekannt: Die Idee besteht darin, aus den Merkmalen jedes Objekts eine Fourier-Reihe zu konstruieren, um die aggregierten Unterschiede zwischen Klassen qualitativ zu visualisieren. Dies kann mit der Funktion pdvega.andrews_curves() erfolgen, die der API von pandas.plotting.andrews_curves() entspricht:

[17]:
pdvega.andrews_curves(iris, "species")