Posts

Artikelserie: BI Tools im Vergleich – Power BI von Microsoft

Den Auftakt dieser Artikelserie zum Vergleich von BI-Tools macht die Softwarelösung Power BI von Microsoft. Solltet ihr gerade erst eingestiegen sein, dann schaut euch ruhig vorher einmal die einführenden Worte und die Ausführungen zur Datenbasis an.

Hier könnt ihr das AdventureWorks2017_PowerBI Dashboard herunterladen und parallel zum Lesen in diesem stöbern.

Lizenzmodell

Power BI ist in seinem Kern ein Cloud-Dienst, welcher als Teil des Serviceportfolios Office 365 von Microsoft angeboten wird. Zusätzlich besteht aber auch die Möglichkeit die Software lokal, also on premise laufen zu lassen.

Power BI Desktop, das Kernelement des Produktportfolios, ist eine frei verfügbare Anwendung und somit schafft Microsoft eine geringe Einstiegsbarriere zur Nutzung der Software. Natürlich gibt es, wie auf dem Markt üblich, Limitierungen, welche den Nutzer zum Kauf animieren. Interessanterweise liegt die Limitierung nicht in den Funktionen der Software selbst, also nicht in dem Aufbau von Visualisierungen, sondern vor allem an der beschränkten Möglichkeit Dashboards in einem Netzwerk zu teilen. Beschränkt, da auch unter der freien Version die Möglichkeit besteht die Dashboards teilen zu können, indem eine Datei gespeichert und weiter versendet wird. Microsoft rät natürlich davon ab und verweist auf die Vorteile der Power BI Pro Lizenz. Dem ist i.d.R. zuzustimmen, da wie im ersten Artikel näher erläutert, ein funktionierendes Konzept zur Data Governance die lokale Erstellung von Dashboards und manuelle Verteilung nicht erlauben würde. Sicherlich gibt es Firmen die Lizenzkosten einsparen wollen und funktionierende Prozesse eingeführt haben, um eine Aktualität und Korrektheit der Dashboards zu gewährleisten. Ein Restrisiko bleibt! Mit $9,99 pro Monat für eine Power BI Pro Lizenz stehen demgegenüber geringe Lizenzkosten (je Mitarbeiter). Das Lizenzmodell ist sehr transparent und zudem besteht keine Verpflichtung zur Abnahme einer Mindestmenge an Lizenzen, also ist der Einstieg auch für kleine Unternehmen gut möglich. Unter der Pro Lizenz besteht aber noch eine weitere wesentliche Limitierung in Bezug auf das Teilen von Dashboards im Power BI Service. Die auf der Cloud bereitgestellten Dashboards benötigen Speicherplatz und bei Intensivierung der Nutzung von Power BI, steigt auch in den meisten Fällen der Speicherplatzbedarf. Eine Erweiterung der Pro Lizenz ist die Power BI Premium Lizenz, mit welcher die maximale Größe eines veröffentlichten Datasets von 1GB auf 10GB erhöht werden kann und des Weiteren die maximale Speicherplatzlimitierung von 10GB pro Benutzer auf 100TB über alle Benutzer erhöht werden kann. Die Kosten für die Premium Lizenz belaufen sich auf momentan $4.995 pro Monat und pro Speicherressource (Cloud), also i.d.R. je Kunde. Sollte eine cloudbasierte Lösung aus Kosten, Technik oder sogar Data Governance Gründen nicht möglich sein, dann kann der Power BI Report Server auf einer selbstgewählten Infrastruktur betrieben werden. Eine Premium Lizenz ermöglicht die lokale Bereitstellung der Software.

Anmerkung: Sowohl die Pro als auch die Premium Lizenz umfassen weitere Leistungen, welche in Einzelfällen ähnlich bedeutend sein können, wie die zuvor beschriebene Veröffentlichung von Dashboards.

Um nur einige wenige zu nennen:

  • Eingebettete Dashboards auf Webseiten oder anderer SaaS Anwendungen
  • Nutzung der Power BI mobile app
  • Inkrementelle Aktualisierung von Datenquellen
  • Erhöhung der Anzahl automatischer Aktualisierungen pro Tag (Pro = 8)
  • u.v.m.

Community & Features von anderen Entwicklern

Power BI Benutzer können sich einer sehr großen Community erfreuen, da diese Software sich laut Gartner unter den führenden BI Tools befindet und Microsoft einen großen Kundenstamm vorzuzeigen hat. Dementsprechend gibt es nicht nur auf der Microsoft eigenen Webseite https://community.powerbi.com/ eine Vielzahl von Themen, welche erörtert werden, sondern behandeln auch die einschlägigen Foren Problemstellungen und bieten Infomaterial an. Dieser große Kundenstamm bietet eine attraktive Geschäftsgrundlage für Entwickler von Produkten, jene komplementär oder gar substitutiv zu einzelnen Funktionen von Power BI angeboten werden. Ein gutes Beispiel für einen ersetzenden Service ist das Tool PowerBI Robots, welches mit Power BI verbunden, automatisch generierte E-Mails mit Screenshots von Dashboards an beliebig viele Personen sendet. Da keiner von Ihnen dafür eine Power BI Pro Lizenz benötigt, hebelt dieser Service die wichtige Veröffentlichungsfunktion zu Teilen aus und einer der Hauptgründe zur Beschaffung der Pro Lizenz fällt zum Teil weg. Weiterhin werden Features ergänzt, welche noch nicht durch Microsoft selbst angeboten werden, wie z.B. die Erweiterung um ein Process Mining Tool namens PAFnow. Dieses und viele weitere Angebote können auf der Marketplaceplattform heruntergeladen werden, sofern man eine Pro Lizenz besitzt.

Daten laden: Allgmeines

Ein sehr großes Spektrum an Datenquellen wird von Power BI unterstützt und fasst jeder Nutzer sollte auf seinen Datenbestand zugreifen können. Mögliche Datenquellen sind natürlich diverse Textdateien, SaaS verschiedenster Anbieter und Datenbanken jeglicher Art, aber auch Python, R Skripte sowie Blank Queries können eingebunden werden. Ebenfalls besteht die Möglichkeit mit einer ODBC Schnittstelle eine Verbindung zu diversen nicht aufgelisteten Datenquellen herstellen zu können. Ein wesentlicher Unterschied zwischen den einzelnen Datenquellen besteht in der Limitierung eine direkte Verbindung aufsetzen zu können, eine sogenannte DirectQuery. In der Dokumentation zu Datenquellen findet man eine Auflistung mit entsprechender Info zur DirectQuery. Die Alternative dazu ist ein Import der Daten in Kombination mit regelmäßig durchgeführten Aktualisierungen. Mit Dual steht dem Anwender ein Hybrid aus beiden Methoden zur Verfügung, welcher in besonderen Anwendungsfällen sinnvoll sein kann. Demnach können einzelne Tabellen als Dual definiert werden und die im Folgenden beschriebenen Vorteile beider Methoden genutzt werden.

Import vs DirectQuery

Welche Verbindung man wählen sollte, hängt von vielen Faktoren ab. Wie bereits erwähnt besteht eine Limitierung von 8 Aktualisierungen pro Tag und Dataset bei importierten Datenquellen, sofern man nur eine Pro Lizenz besitzt. Mit der Nutzung einer DirectQuery besteht diese Limitierung nicht. Ebenfalls existiert keine Beschränkung in Bezug auf die Uploadgröße von 1GB je Dataset. Eine stetige Aktualität der Reports ist unter der Einstellung DirectQuery selbst redend.

Wann bringt also der Import Vorteile?

Dieser besteht im Grunde in der technischen Limitierung von DirectQuery‘s, welche wären:

  • Es können nicht mehr als 1 Mio. Zeilen zurückgegeben werden (Aggregationen wiederum können über mehr Zeilen laufen)
  • Es können nur eingeschränkt Measures (Sprache DAX) geschrieben werden
  • Fehler im Abfrageeditor bei übermäßiger Komplexität von Abfragen
  • Zeitintelligenzfunktionen sind nicht verfügbar

Daten laden: AdventuresWorks2017Dataset

Wie zu erwarten verlief der Import der Daten reibungslos, da sowohl die Datenquelle als auch das Dataset ein Produkt Microsoft‘s sind. Ein Import war notwendig, um Measures unter Nutzung von DAX anzuwenden. Power BI ermöglichte es die Daten schnell in das Tool zu laden.

Beziehungen zwischen Datentabellen werden durch die Software entweder aufgrund von automatischer Erkennung gleicher Attribute über mehrere Tabellen hinweg oder durch das Laden von Metadaten erkannt. Aufgrund des recht komplexen und weit verzweigten Datasets schien dieses Feature im ersten Moment von Vorteil zu sein, erst in späteren Visualisierungsschritten stellte sich heraus das einige Verbindungen nicht aus den Metadaten geladen wurden, da eine falsch gesetzte Beziehung durch eine automatische Erkennung gesetzt wurde und so die durch die Metadaten determinierte Beziehung nicht übernommen werden konnte. Lange Rede kurzer Sinn: Diese Automatisierung ist arbeitserleichternd und nützlich, insbesondere für Einsteiger, aber das manuelle Setzen von Beziehungen kann wenig auffällige Fehler vermeiden und fördert zugleich das eigene Verständnis für die Datengrundlage. Microsoft bietet seinen Nutzer an diese Features zu deaktivieren und das manuelle Setzen der Beziehungen ist über das Userinterface (UI) im Register „Beziehungen“ einfach umzusetzen. Besonders positiv ist die Verwirklichung dieses Registers, da der Nutzer ein einfach zu bedienendes Tool zur Strukturierung der Daten erhält. Ein Entity-Relationship-Modell (ERM) zeigt das Resultat der Verknüpfung und zugleich das Datenmodel gemäß dem Konzept eines Sternenschemas.

Daten transformieren

Einer der wesentlichen Instrumente zur Transformierung von Daten ist Power Query. Diese Software ist ebenfalls ein etablierter Bestandteil von Excel und verfügt über ein gelungenes UI, welches die Sprache M generiert. Ca. 95% der gewünschten Daten Transformationen können über das UI durchgeführt werden und demnach ist es in den meisten Fällen nicht notwendig M schreiben zu müssen. Durch das UI ermöglicht Power Query wesentliche Aufgaben wie das Bereinigen, Pivotieren und Zusammenführen von Daten umzusetzen. Aber es ist von Vorteil, wenn man sich zumindest mit der Syntax auskennt und die Sprache in groben Zügen versteht. Die Sprache M wie auch das UI, welches unter anderem die einzelnen Bearbeitungs-/Berechnungsschritte aufzeigt, ist Workflow-orientiert. Das UI ist gut strukturiert und Nutzer finden schnellen Zugang zur funktionsweise. Ein sehr gut umgesetztes Beispiel ist die Funktion „Spalten aus Beispielen“. In nur wenigen Schritten konnten der Längen- und Breitengrad aus einer zusammengefassten Spalte getrennt werden. Den erzeugten M Code und den beschriebenen Workflow seht ihr in der folgenden Grafik.

Das Feature zur Zusammenführung von Tabellen ist jedoch problematisch, da das UI von Power Query dem Nutzer keine vorprogrammierten Visualisierungen o.ä. an die Hand gibt, um die Resultate überprüfen zu können. Wie bei dem Beispiel Dataset von Microsoft, welches mit über 70 Tabellen eine relativ komplexe Struktur aufweist, können bei unzureichender Kenntnis über die Struktur der Datenbasis Fehler entstehen. Eine mögliche Folge können die ungewollte Vervielfachung von Zeilen (Kardinalität ist „viele zu viele“) oder gar das Fehlen von Informationen sein (nur eine Teilmenge ist in die Verknüpfung eingeschlossen). Zur Überprüfung der JOIN Ergebnisse können die drei genannten Register (siehe obige Grafik) dienen, aber ein Nutzer muss sich selbst ein eigenes Vorgehen zur Überwachung der korrekten Zusammenführung überlegen.

Nachdem die Bearbeitung der Daten in Power Query abgeschlossen ist und in Power BI geladen werden, besteht weiterhin die Möglichkeit Daten unter Nutzung von DAX zu transformieren. Insbesondere Measures bedienen sich ausschließlich dieser Sprache und ein gutes Auto-Fill-Feature mit zusätzlicher Funktionsbeschreibung erleichtern das Schreiben in DAX. Dynamische Aggregationen und etliche weitere Kalkulationen sind denkbar. Folgend findet ihr einige wenige Beispiele vor, welche auch im AdventureWorks Dashboard Anwendung finden:

Measures können komplexe Formen annehmen und Power BI bietet eine sehr gute Möglichkeit gebräuchliche Berechnungen über sogenannte Quickmeasures (QM) vorzunehmen. Ähnlich wie für die Sprache M gibt es ein UI zur Erstellung dieser, ohne eine Zeile Code schreiben zu müssen. Die Auswahl an QM ist groß und die Anwendungsfälle für die einzelnen QM sind vielfältig. Als Beispiel könnt ihr euch das Measure „Kunden nach Year/KPI/Category“ im bereitgestellten AdventureWorks Dashboard anschauen, welches leicht abgewandelt auf Grundlage des QM „Verkettete Werteliste“ erstellt wurde. Dieses Measure wurde als dynamischer Titel in das Balkendiagramm eingebunden und wie das funktioniert seht ihr hier.

Daten visualisieren

Der letzte Schritt, die Visualisierung der Daten, ist nicht nur der wichtigste, sondern auch der sich am meisten unterscheidende Schritt, vergleicht man die einzelnen BI-Tools. Ein wesentlicher Faktor dabei ist die Arbeitsabfolge in Bezug auf den Bau von Visualisierungen. Power BI ermöglicht dem Nutzer einzelne Grafiken in einem UI zu gestalten und in dem selbigen nach Belieben anzuordnen. Bei Tableau und Looker zum Beispiel werden die einzelnen Grafiken in separaten UIs gestaltet und in einem weiteren UI als Dashboard zusammengesetzt. Eine Anordnung der Visualisierungen ist in Power BI somit sehr flexibel und ein Dashboard kann in wenigen Minuten erstellt werden. Verlieren kann man sich in den Details, fast jede visuelle Vorstellung kann erfüllt werden und in der Regel sind diese nur durch die eigene Zeit und das Know-How limitiert. Ebenfalls kann das Repertoire an Visualisierungen um sogenannte Custom Visualizations erweitert werden, sofern man eine Pro Lizenz besitzt ist das Herunterladen dieser Erweiterungen unter AppSource möglich.

Eine weitere Möglichkeit zur Anreicherung von Grafiken um Detailinformationen, besteht über das Feature Quickinfo. Sowohl eine schnell umsetzbare und somit wenig detaillierte Einbindung von Details ist möglich, aber auch eine aufwendigere Alternative ermöglicht die Umsetzung optisch ansprechender und sehr detaillierter Quickinfos.

Das Setzen von Filtern kann etliche Resultate und Erkenntnisse mit sich bringen. Dem Nutzer können beliebige Ansichten bzw. Filtereinstellungen in sogenannten Bookmarks gespeichert werden, sodass ein einziger Klick reicht. In dem AdventureWorks Dashboard wurde ein nützliches Bookmark verwendet, welches dem Zurücksetzen aller Filter dient.

Erstellt man Visualisierungen in immer gleichem Format, dann lohnt es sich ein eigenes Design in JSON Format zu erstellen. Wenn man mit diesem Format nicht vertraut ist, dann kann man eine Designvorlage über das Tool Report Theme Generator V3 sehr einfach selbst erstellen.

Existiert ein Datenmodell und Daten aus verschiedenen Tabellen werden im selben Dashboard zusammengestellt (siehe auch Beispiel Dashboard AdventureWorks), dann werden entsprechende JOIN Operationen im Hintergrund beim Zusammenstellen der Visualisierung erstellt. Ob das Datenmodell richtig aufgebaut wurde, ist oft erst in diesem Schritt erkennbar und wie bereits erwähnt, muss sich ein jeder Anwender ein eigenes Vorgehen überlegen mit Hilfe dieses Features die vorausgegangenen Schritte zu kontrollieren.

Warum braucht Power BI eine Python Integration?

Interessant ist dieses Feature in Bezug auf Machine Learning Algorithmen, welche direkt in Power BI integriert werden können. Python ist aber auch für einige Nutzer eine gern genutzte Alternative zu DAX und M, sofern man sich mit diesen Sprachen nicht auseinandersetzen möchte. Daten Transformationen und Visualisierungen durch die allseits bekannten Plots sind somit zwei weitere wesentliche Gründe warum Nutzer Python einbinden. Zudem können weitere Quellen eingebunden werden. Ein Vorteil von Python ist ein Repertoire an vielen nützlichen Bibliotheken wie pandas, matplotlib u.v.m.. Jedoch ist zu bedenken, dass die Python Skripte zur Datenbereinigung und zur Abfrage der Datenquelle erst durch den Data Refresh in Power BI ausgeführt werden. In DAX geschriebene Measures bieten den Vorteil, dass diese mehrmals verwendet werden können. Ein Python Skript hingegen muss kopiert und demnach auch mehrfach instandgehalten werden.

Es ist ratsam Python in Power BI nur zu nutzen, wenn man an die Grenzen von DAX und M kommt.

Fazit

Das Lizenzmodel ist einfach strukturiert und transparent. Bereits kleine Firmen können ein Einstieg in Power BI finden, da kein Mindestumsatz gefordert ist.

Gut aufbereitete Daten können ohne großen Aufwand geladen werden und bis zum Aufbau erster Visualisierungen bedarf es nicht vieler Schritte, jedoch sind erste Resultate sehr kritisch zu hinterfragen. Die Kontrolle automatisch generierter Beziehungen und das Schreiben von zusätzlichen DAX Measures zur Verwendung in den Visualisierungen ist in den meisten Fällen notwendig, um eine korrekte Darstellung der Zahlen zu gewährleisten.

Die Transformation der Daten kann zum großen Teil über unterschiedliche UIs umgesetzt werden, jedoch ist das Schreiben von Code ab einem gewissen Punkt unumgänglich und wird auch nie komplett vermeidbar sein. Power BI bietet aber bereits ein gut durchdachtes Konzept.

Im Großen und Ganzen ist Power BI ein ausgereiftes und sehr gut handhabbares Produkt mit etlichen Features, ob von Microsoft selbst oder durch Drittanbieter angeboten. Eine große Community bietet ebenfalls Hilfestellung bei fast jedem Problem, wenn dieses nicht bereits erörtert wurde. Hervorzuheben ist der Kern des Produkts: die Visualisierungen. Einfach zu erstellende Visualisierungen jeglicher Art in einem ansprechenden Design grenzen dieses Produkt von anderen ab.

Fortsetzung folgt… Tableau wird als zweites Tool dieser Artikelserie näher beleuchtet.

Training eines Neurons mit dem Gradientenverfahren

Dies ist Artikel 3 von 6 der Artikelserie –Einstieg in Deep Learning.

Das Training von neuronalen Netzen erfolgt nach der Forward-Propagation über zwei Schritte:

  1. Fehler-Rückführung über aller aktiver Neuronen aller Netz-Schichten, so dass jedes Neuron “seinen” Einfluss auf den Ausgabefehler kennt.
  2. Anpassung der Gewichte entgegen den Gradienten der Fehlerfunktion

Beide Schritte werden in der Regel zusammen als Backpropagation bezeichnet. Machen wir erstmal einen Schritt vor und betrachten wir, wie ein Neuron seine Gewichtsverbindungen zu seinen Vorgängern anpasst.

Gradientenabstiegsverfahren

Der Gradientenabstieg ist ein generalisierbarer Algorithmus zur Optimierung, der in vielen Verfahren des maschinellen Lernens zur Anwendung kommt, jedoch ganz besonders als sogenannte Backpropagation im Deep Learning den Erfolg der künstlichen neuronalen Netze erst möglich machen konnte.

Der Gradientenabstieg lässt sich vom Prinzip her leicht erklären: Angenommen, man stünde im Gebirge im dichten Nebel. Das Tal, und somit der Weg nach Hause, ist vom Nebel verdeckt. Wohin laufen wir? Wir können das Ziel zwar nicht sehen, tasten uns jedoch so heran, dass unser Gehirn den Gradienten (den Unterschied der Höhen beider Füße) berechnet, somit die Steigung des Bodens kennt und sich entgegen dieser Steigung unser Weg fortsetzt.

Konkret funktioniert der Gradientenabstieg so: Wir starten bei einem zufälligen Theta \theta (Random Initialization). Wir berechnen die Ausgabe (Forwardpropogation) und vergleichen sie über eine Verlustfunktion (z. B. über die Funktion Mean Squared Error) mit dem tatsächlich korrekten Wert. Auf Grund der zufälligen Initialisierung haben wir eine nahe zu garantierte Falschheit der Ergebnisse und somit einen Verlust. Für die Verlustfunktion berechnen wir den Gradienten für gegebene Eingabewerte. Voraussetzung dafür ist, dass die Funktion ableitbar ist. Wir bewegen uns entgegen des Gradienten in Richtung Minimum der Verlustfunktion. Ist dieses Minimum (fast) gefunden, spricht man auch davon, dass der Lernalgorithmus konvergiert.

Das Gradientenabstiegsverfahren ist eine Möglichkeit der Gradientenverfahren, denn wollten wir maximieren, würden wir uns entlang des Gradienten bewegen, was in anderen Anwendungen sinnvoll ist.

Ob als “Cost Function” oder als “Loss Function” bezeichnet, in jedem Fall ist es eine “Error Function”, aber auf die Benennung kommen wir später zu sprechen. Jedenfalls versuchen wir die Fehlerrate zu senken! Leider sind diese Funktionen in der Praxis selten so einfach konvex (zwei Berge mit einem Tal dazwischen).

 

Aber Achtung: Denn befinden wir uns nur zwischen zwei Bergen, finden wir das Tal mit Sicherheit über den Gradienten. Befinden wir uns jedoch in einem richtigen Gebirge mit vielen Bergen und Tälern, gilt es, das richtige Tal zu finden. Bei der Optimierung der Gewichtungen von künstlichen neuronalen Netzen wollen wir die besten Gewichtungen finden, die uns zu den geringsten Ausgaben der Verlustfunktion führen. Wir suchen also das globale Minimum unter den vielen (lokalen) Minima.

Programmier-Beispiel in Python

Nachfolgend ein Beispiel des Gradientenverfahrens zur Berechnung einer Regression. Wir importieren numpy und matplotlib.pyplot und erzeugen uns künstliche Datenpunkte:

import numpy as np
import matplotlib.pyplot as plt


X = 2 * np.random.rand(1000, 1)
y = 5 + 2 * X + np.random.randn(1000, 1)

plt.figure(figsize = (15, 15))
plt.plot(X, y, "b.")
plt.axis([0, 2, 0, 15])
plt.show()

Nun wollen wir einen Lernalgorithmus über das Gradientenverfahren erstellen. Im Grunde haben wir hier es bereits mit einem linear aktivierten Neuron zutun:

Bei der linearen Regression, die wir durchführen wollen, nehmen wir zwei-dimensionale Daten (wobei wir die Regression prinzipiell auch mit x-Dimensionen durchführen können, dann hätte unser Neuron weitere Eingänge). Wir empfangen einen Bias (w_0) der stets mit einer Eingangskonstante multipliziert und somit als Wert erhalten bleibt. Der Bias ist das Alpha \alpha in einer Schulmathe-tauglichen Formel wie y = \beta \cdot x + \alpha.

Beta \beta ist die Steigung, der Gradient, der Funktion.

Sowohl \alpha als auch \beta sind uns unbekannt, versuchen wir jedoch über die Betrachtung unserer Prädiktion durch Berechnung der Formel \^y = \beta \cdot x + \alpha und den darauffolgenden Abgleich mit dem tatsächlichen y herauszufinden. Anfangs behaupten wir beispielsweise einfach, sowohl \beta als auch \alpha seien 0.00. Folglich wird \^y = \beta \cdot x + \alpha ebenfalls gleich 0.00 sein und die Fehlerfunktion (Loss Function) wird maximal sein. Dies war der erste Durchlauf des Trainings, die sogenannte erste Epoche!

Die Epochen (Durchläufe) und dazugehörige Fehlergrößen. Wenn die Fehler sinken und mit weiteren Epochen nicht mehr wesentlich besser werden, heißt es, das der Lernalogorithmus konvergiert.

Als Fehlerfunktion verwenden wir bei der Regression die MSE-Funktion (Mean Squared Error):

MSE = \sum(\^y_i - y_i)^2

Um diese Funktion wird sich nun alles drehen, denn diese beschreibt den Fehler und gibt uns auch die Auskunft darüber, ob wie stark und in welche Richtung sie ansteigt, so dass wir uns entgegen der Steigung bewegen können. Wer die Regeln der Ableitung im Kopf hat, weiß, dass die Ableitung der Formel leichter wird, wenn wir sie vorher auf halbe Werte runterskalieren. Da die Proportionen dabei erhalten bleiben und uns quadrierte Fehlerwerte unserem menschlichen Verstand sowieso nicht so viel sagen (unser Gehirn denkt nunmal nicht exponential), stört das nicht:

MSE = \frac{\frac{1}{2} \cdot \sum(\^y_i - y_i)^2}{n}

MSE = \frac{\frac{1}{2} \cdot \sum(w^T \cdot x_i - y_i)^2}{n}

Wenn die Mathematik der partiellen Ableitung (Ableitung einer Funktion nach jedem Gradienten) abhanden gekommen ist, bitte nochmal folgende Regeln nachschlagen, um die nachfolgende Ableitung verstehen zu können:

  • Allgemeine partielle Ableitung
  • Kettenregel

Ableitung der MSD-Funktion nach dem einen Gewicht w bzw. partiell nach jedem vorhandenen w_j:

\frac{\partial}{\partial w_j}MSE = \frac{\partial}{\partial w} \frac{1}{2} \cdot \sum(\^y - y_i)^2

\frac{\partial}{\partial w_j}MSE = \frac{\partial}{\partial w} \frac{1}{2} \cdot \sum(w^T \cdot x_i - y_i)^2

\frac{\partial}{\partial w_j}MSE = \frac{2}{n} \cdot \sum(w^T \cdot x_i - y_i) \cdot x_{ij}

Woher wir das x_{ij} am Ende her haben? Das ergibt sie aus der Kettenregel: Die äußere Funktion wurde abgeleitet, so wurde aus \frac{1}{2} \cdot \sum(w^T \cdot x_i - y_i)^2 dann \frac{2}{n} \cdot \sum(w^T \cdot x_i - y_i). Jedoch muss im Sinne eben dieser Kettenregel auch die innere Funktion abgeleitet werden. Da wir nach w_j ableiten, bleibt nur x_ij erhalten.

Damit können wir arbeiten! So kompliziert ist die Formel nun auch wieder nicht: \frac{2}{n} \cdot \sum(w^T \cdot x_i - y_i) \cdot x_{ij}

Mit dieser Formel können wir unsere Gewichte an den Fehler anpassen: (f\nabla ist der Gradient der Funktion!)

w_j = w_j - \nabla MSE(w_j)

Initialisieren der Gewichtungen

Die Gewichtungen \alpha und \beta müssen anfänglich mit Werten initialisiert werden. In der Regression bietet es sich an, die Gewichte anfänglich mit 0.00 zu initialisieren.

Bei vielen neuronalen Netzen, mit nicht-linearen Aktivierungsfunktionen, ist das jedoch eher ungünstig und zufällige Werte sind initial besser. Gut erprobt sind normal-verteilte Zufallswerte.

Lernrate

Nur eine Kleinigkeit haben wir bisher vergessen: Wir brauchen einen Faktor, mit dem wir anpassen. Hier wäre der Faktor 1. Das ist in der Regel viel zu groß. Dieser Faktor wird geläufig als Lernrate (Learning Rate) \eta (eta) bezeichnet:

w_j = w_j - \eta \cdot \nabla MSE(w_j)

Die Lernrate \eta ist ein Knackpunkt und der erste Parameter des Lernalgorithmus, den es anzupassen gilt, wenn das Training nicht konvergiert.

Die Lernrate \eta darf nicht zu groß klein gewählt werden, da das Training sonst zu viele Epochen benötigt. Ungeduldige erhöhen die Lernrate möglicherweise aber so sehr, dass der Lernalgorithmus im Minimum der Fehlerfunktion vorbeiläuft und diesen stets überspringt. Hier würde der Algorithmus also sozusagen konvergieren, weil nicht mehr besser werden, aber das resultierende Modell wäre weit vom Optimum entfernt.

Beginnen wir mit der Implementierung als Python-Klasse:

class LinearRegressionGD(object):
    
    def __init__(self, eta = 0.0001, n_iter = 50):
        
        self.eta = eta                  # Lernrate
        self.n_iter = n_iter            # Epochen
        
    def fit(self, X, y):
        
        self.w_ = np.zeros(1 + X.shape[1]) # <- 1 für den Bias + alle weiteren Columns für die Steigungen
                                           # In diesem Beispiel self.w_ = [0.0, 0.] = [Alpha, Beta]
                                           # Dabei initialisieren wir Alpha und Beta mit 0.00-Werten
        
        self.cost_ = []                    # Cost Function (der Verlauf der Loss Function MSE)
        
        for i in range(self.n_iter):       # Für jede Epoche...
            
            output = self.predict(X)       # Die Funktion x * Beta + Alpha ausrechnen  
                                           # Batch-Verfahren, denn wir trainieren jede Epoche mit allen X-Werten

            errors = y.flatten() - output  # y_predicted - y_real

            mse = ((errors ** 2).sum() / 2.0) / len(X)  # Loss Function MSE
            
            self.cost_.append(mse)                      # Loss Function wird Teil der Cost Function
            
            self.w_[1:] += self.eta * X.T.dot(errors)   # Anpassen des Gewichts Beta (und falls es sie gäbe: aller weiteren Gewichte)
            self.w_[0] += self.eta * errors.sum()      # Anpassen des Gewichts Alpha
            
            
            #print(output)
            #print(errors)
            #print("Beta  -> ", self.w_[1:])
            #print("Alpha -> ", self.w_[0])                   
            
        return self
        
    def predict(self, X):
        return np.dot(X, self.w_[1:]) + self.w_[0]      # y = x * Beta + Alpha

Die Klasse sollte so funktionieren, bevor wir sie verwenden, sollten wir die Input-Werte standardisieren:

x_std = (X - X.mean()) / X.std()
y_std = (y - y.mean()) / y.std()

Bei diesem Beispiel mit künstlich erzeugten Werten ist das Standardisieren bzw. das Fehlen des Standardisierens zwar nicht kritisch, aber man sollte es sich zur Gewohnheit machen. Testweise es einfach mal weglassen 🙂

Kommen wir nun zum Einsatz der Klasse, die die Regression via Gradientenabstieg absolvieren soll:

lrGD = LinearRegressionGD()  # Instanziieren
lrGD.fit(x_std, y_std)       # Trainieren (das ".fit()" entspricht dem Wording von scikit-learn, ".train()" wäre mir sonst lieber :-)

Was tut diese Instanz der Klasse LinearRegressionGD nun eigentlich?

Bildlich gesprochen, legt sie eine Gerade auf den Boden des Koordinatensystems, denn die Gewichtungen werden mit 0.00 initialisiert, y ist also gleich 0.00, egal welche Werte in x enthalten sind. Der Fehler ist dann aber sehr groß (sollte maximal sein, im Vergleich zu zukünftigen Epochen). Die Gewichte werden also angepasst, die Gerade somit besser in die Punktwolke platziert. Mit jeder Epoche wird die Gerade erneut in die Punktwolke gelegt, der Gesamtfehler (über alle x, da wir es hier mit dem Batch-Verfahren zutun haben) berechnet, die Werte angepasst… bis die vorgegebene Zahl an Epochen abgelaufen ist.

Schauen wir uns das Ergebnis des Trainings an:

plt.figure(figsize = (15, 15))
plt.plot(x_std, y_std, "b.")                                # Scatter, wie zuvor!
plt.plot(x_std, lrGD.predict(x_std), "r-", linewidth = 5)   # Regressionsgerade als Linie
plt.show()

Die Linie sieht passend aus, oder? Da wir hier nicht zu sehr in die Theorie der Regressionsanalyse abdriften möchten, lassen wir das testen und prüfen der Akkuratesse mal aus, hier möchte ich auf meinen Artikel Regressionsanalyse in Python mit Scikit-Learn verweisen.

Prüfen sollten wir hingegen mal, wie schnell der Lernalgorithmus mit der vorgegebenen Lernrate eta konvergiert:

plt.figure(figsize = (15, 15))
plt.plot(range(1, lrGD.n_iter + 1), lrGD.cost_)
plt.xlabel('Epochen')
plt.ylabel('Summe quadrierter Abweichungen')
plt.show()

Hier die Verlaufskurve der Cost Function:

Die Kurve zeigt uns, dass spätestens nach 40 Epochen kaum noch Verbesserung (im Sinne der Gesamtfehler-Minimierung) erreicht wird.

Wichtige Hinweise

Natürlich war das nun nur ein erster kleiner Einstieg und wer es verstanden hat, hat viel gewonnen. Denn erst dann kann man sich vorstellen, wie ein einzelnen Neuron eines künstlichen neuronalen Netzes grundsätzlich trainiert werden kann.

Folgendes sollte noch beachtet werden:

  • Lernrate \eta:
    Die Lernrate ist ein wichtiger Parameter. Wer das Programmier-Beispiel bei sich zum Laufen gebracht hat, einfach mal die Lernrate auf Werte zwischen 10.00 und 0.00000001 setzen, schauen was passiert 🙂
  • Globale Minima vs lokale Minima:
    Diese lineare zwei-dimensionale Regression ist ziemlich einfach. Neuronale Netze sind hingegen komplexer und haben nicht einfach nur eine simple konvexe Fehlerfunktion. Hier gibt es mehrere Hügel und Täler in der Fehlerfunktion und die Gefahr ist groß, in einem lokalen, nicht aber in einem globalen Minimum zu landen.
  • Stochastisches Gradientenverfahren:
    Wir haben hier das sogenannte Batch-Verfahren verwendet. Dieses ist grundsätzlich besser als die stochastische Methode. Denn beim Batch verwenden wir den gesamten Stapel an x-Werten für die Fehlerbestimmung. Allerdings ist dies bei großen Daten zu rechen- und speicherintensiv. Dann werden kleinere Unter-Stapel (Sub-Batches) zufällig aus den x-Werten ausgewählt, der Fehler daraus bestimmt (was nicht ganz so akkurat ist, wie als würden wir den Fehler über alle x berechnen) und der Gradient bestimmt. Dies ist schon Rechen- und Speicherkapazität, erfordert aber meistens mehr Epochen.

Buchempfehlung

Die folgenden zwei Bücher haben mir bei der Erstellung dieses Beispiels geholfen und kann ich als hilfreiche und deutlich weiterführende Lektüre empfehlen:

 

Machine Learning mit Python und Scikit-Learn und TensorFlow: Das umfassende Praxis-Handbuch für Data Science, Predictive Analytics und Deep Learning (mitp Professional) Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques for Building Intelligent Systems

 

Self Service Data Preparation mit Microsoft Excel

Get & Transform (vormals Power Query), eine kurze Einführung

 Unter Data Preparation versteht man sinngemäß einen Prozeß der Vorbereitung / Aufbereitung von Rohdaten aus meistens unterschiedlichen Datenquellen und -formaten, verbunden mit dem Ziel, diese effektiv für verschiedene Geschäftszwecke / Analysen (Business Fragen) weiterverwenden/bereitstellen zu können. Rohdaten müssen oft vor ihrem bestimmungsgemäßen Gebrauch transformiert (Datentypen), integriert (Datenkonsistenz, referentielle Integrität), sowie zugeordnet (mapping; Quell- zu Zieldaten) werden.
An diesem neuralgischen Punkt werden bereits die Weichen für Datenqualität gestellt.

Unter Datenqualität soll hier die Beschaffenheit / Geeignetheit von Daten verstanden werden, um konkrete Fragestestellungen beantworten zu können (fitness for use):

Kriterien Datenqualität

  • Eindeutigkeit
  • Vollständigkeit
  • Widerspruchsfreiheit / Konsistenz
  • Aktualität
  • Genauigkeit
  • Verfügbarkeit

Datenqualität bestimmt im Wesentlichen die weitere zielgerichtete Verwendung der Daten in Analysen (Modelle) und Berichten (Reporting). Daten werden in entscheidungsrelevante Kennzahlen (Informationen) überführt. Eine Kennzahl ist gegenüber der Datenqualität immer blind, ihre Aussagekraft (Validität) hängt -neben der Definition – in sehr starkem Maße davon ab:

Gütekriterien von Kennzahlen

  • Objektivität := ist die Interpretation unabhängig vom Beobachter / Verwender?
  • Reliabilität := kann das Ergebnis unter sonst gleichen Bedingungen reproduziert werden ?
  • Validität := sagt die Kennzahl das aus, was sie vorgibt, auszusagen ?

Business Fragen entstehen naturgemäß in den Fachbereichen.Daher ist es nur folgerichtig, Data Preparation als einen ersten Analyseschritt innerhalb des Fachbereichs anzusiedeln (Self Service Data Preparation). Dadurch erhält der Fachbereich einen Teil seiner Autonomie zurück. Welche Teilmenge der Daten relevant für Fragestellungen ist, kann nur der Fachbereich beurteilen; der Anforderer von entscheidungsrelevanten Informationen sollte idealerweiseTeil der Entstehung wertiger Daten sein, das fördert zum einen die Akzeptanz des Ergebnisses, zum anderen wirkt es einem „not-invented-here“ Syndrom frühzeitig entgegen.

Im Folgenden wird anhand 4 Schritten skizziert, wie Microsoft Excel bei dem Thema (Self Service) Data Preparation vor allem den Fachbereich unterstützen kann. Eine Beispieldatei können Sie hier (google drive) einsehen. Sie finden die hierfür verwendete Funktionalität (Get & Transform) in Excel 2016 unter:

Reiter Daten -> Abrufen und Transformieren.

Dem interessierten Leser werden im Text vertiefende Informationen über links zu einzelnen typischen Aufgabenstellungen und Lösungswegen angeboten. Eine kurze Einführung in das Thema finden Sie in diesem Blog Beitrag.

1 Einlesen

Datenquellen anbinden (externe, interne)

Dank der neuen Funktionsgruppe „Abrufen und Transformieren“ ist es in Microsoft Excel möglich, verschiedene externe Datenquellen /-formate anzubinden. Zusätzlich können natürlich auch Tabellen der aktiven / offenen Excel Arbeitsmappe als Datenquelle dienen (interne Datenquellen). Diese Datenquellen werden anschließend als sogenannte Arbeitsmappenabfragen abgebildet.

Praxisbeispiele:

Anbindung mehrerer Dateien, welche in einem Ordner bereitgestellt werden

Anbindung von Webinhalten

2 Transformieren

Daten transformieren (Datentypen, Struktur)

Datentypen (Text, Zahl) können anschließend je Arbeitsmappenabfrage und Spalte(n) geändert werden.
Dies ist zB immer dann notwendig, wenn Abfragen über Schlüsselspalten in Beziehung gesetzt werden sollen (siehe Punkt 3). Gleicher Datentyp (Primär- und Fremdschlüssel) in beiden Tabellen ist hier notwendige Voraussetzung.

Des Weiteren wird in dieser Phase typischerweise festgelegt, welche Zeile der Abfrage die Spaltenbeschriftungen enthält.

Praxisbeispiele:

Fehlerbehandlung

Leere Zellen auffüllen

Umgang mit wechselnden Spaltenbeschriftungen

3 Zusammenführen / Anreichern

Daten zusammenführen (SVERWEIS mal anders)

Um unterschiedliche Tabellen / Abfragen über gemeinsame Schlüsselspalten zusammenzuführen, stellt der Excel Abfrage Editor eine Reihe von JOIN-Operatoren zur Verfügung, welche ohne SQL-Kenntnisse nur durch Anklicken ausgewählt werden können.

Praxisbeispiele

JOIN als Alternative zu Excel Formel SVERWEIS()

Daten anreichern (benutzerdefinierte Spalte anfügen)

Bei Bedarf können weitere Daten, welche sich nicht in der originären Struktur der Datenquelle befinden, abgeleitet werden. Die Sprache Language M stellt einen umfangreichen Katalog an Funktionen zur Verfügung. Wie Sie eine Übersicht über die verfügbaren Funktionen erhalten können erfahren Sie hier.

Praxisbeispiele

Geschäftsjahr aus Datum ableiten

Extraktion Textteil aus Text (Trunkation)

Mehrfache Fallunterscheidung, Datenbereinigung /-harmonisierung

4 Laden

Daten laden

Die einzelnen Arbeitsmappenabfragen können abschließend in eine Exceltabelle, eine Verbindung und / oder in das Power Pivot Datemodell zur weiteren Bearbeitung (Modellierung, Kennzahlenbildung) geladen werden.

Praxisbeispiele

Datenverbindung erstellen

Unsupervised Learning in R: K-Means Clustering

Die Clusteranalyse ist ein gruppenbildendes Verfahren, mit dem Objekte Gruppen – sogenannten Clustern zuordnet werden. Die dem Cluster zugeordneten Objekte sollen möglichst homogen sein, wohingegen die Objekte, die unterschiedlichen Clustern zugeordnet werden möglichst heterogen sein sollen. Dieses Verfahren wird z.B. im Marketing bei der Zielgruppensegmentierung, um Angebote entsprechend anzupassen oder im User Experience Bereich zur Identifikation sog. Personas.

Es gibt in der Praxis eine Vielzahl von Cluster-Verfahren, eine der bekanntesten und gebräuchlichsten Verfahren ist das K-Means Clustering, ein sog. Partitionierendes Clusterverfahren. Das Ziel dabei ist es, den Datensatz in K Cluster zu unterteilen. Dabei werden zunächst K beliebige Punkte als Anfangszentren (sog. Zentroiden) ausgewählt und jedem dieser Punkte der Punkt zugeordnet, zu dessen Zentrum er die geringste Distanz hat. K-Means ist ein „harter“ Clusteralgorithmus, d.h. jede Beobachtung wird genau einem Cluster zugeordnet. Zur Berechnung existieren verschiedene Distanzmaße. Das gebräuchlichste Distanzmaß ist die quadrierte euklidische Distanz:

D^2 = \sum_{i=1}^{v}(x_i - y_i)^2

Nachdem jede Beobachtung einem Cluster zugeordnet wurde, wird das Clusterzentrum neu berechnet und die Punkte werden den neuen Clusterzentren erneut zugeordnet. Dieser Vorgang wird so lange durchgeführt bis die Clusterzentren stabil sind oder eine vorher bestimmte Anzahl an Iterationen durchlaufen sind.
Das komplette Vorgehen wird im Folgenden anhand eines künstlich erzeugten Testdatensatzes erläutert.

set.seed(123)
Alter <- c(24, 22, 28, 25, 41, 39, 35, 40, 62, 57, 60, 55)
Einkommen <- c(20000, 22000, 25000, 24000, 55000, 65000, 75000, 60000, 30000, 34000, 30000, 34000)
Daten <- as.data.frame(cbind(Alter, Einkommen))

Zunächst wird ein Testdatensatz mit den Variablen „Alter“ und „Einkommen“ erzeugt, der 12 Fälle enthält. Als Schritt des „Data preprocessing“ müssen zunächst beide Variablen standardisiert werden, da ansonsten die Variable „Alter“ die Clusterbildung zu stark beeinflusst.

DatenAlter <- scale(DatenAlter)
DatenEinkommen <- scale(DatenEinkommen)

Das Ganze geplottet:

plot(DatenAlter, DatenEinkommen, col = "blue", pch = 19,
     xlab = "Alter (scaled)",
     ylab = "Einkommen (scaled)",
     main = "Alter vs. Einkommen (scaled)")

Wie bereits eingangs erwähnt müssen Cluster innerhalb möglichst homogen und zu Objekten anderer Cluster möglichst heterogen sein. Ein Maß für die Homogenität die „Within Cluster Sums of Squares“ (WSS), ein Maß für die Heterogenität „Between Cluster Sums of Squares“ (BSS).

Diese sind beispielsweise für eine 3-Cluster-Lösung wie folgt:

KmeansObj <- kmeans(Daten, 3, nstart = 20)
KmeansObjwithinss # Within Cluster Sums of Squares (WSS) KmeansObjtotss # Between Cluster Sums of Suqares (BSS)

> KmeansObjwithinss # Within Cluster Sums of Squares (WSS) [1] 0.7056937 0.1281607 0.1792432 > KmeansObjtotss # Between Cluster Sums of Suqares (BSS)
[1] 22

Sollte man die Anzahl der Cluster nicht bereits kennen oder sind diese extern nicht vorgegeben, dann bietet es sich an, anhand des Verhältnisses von WSS und BSS die „optimale“ Clusteranzahl zu berechnen. Dafür wird zunächst ein leerer Vektor initialisiert, dessen Werte nachfolgend über die Schleife mit dem Verhältnis von WSS und WSS gefüllt werden. Dies lässt sich anschließend per „Screeplot“ visualisieren.

ratio <- vector()
for (k in 1:6) {
    KMeansObj <- kmeans(Daten, k, nstart = 20)
    ratio[k] <- KMeansObjtot.withinss / KMeansObjtotss
}
plot(ratio, type = "b",
     xlab = "Anzahl der Cluster",
     ylab = "Ratio WSS/BSS",
     main = "Screeplot für verschiedene Clusterlösungen",
col = "blue",  pch = 19)

Die „optimale“ Anzahl der Cluster zählt sich am Knick der Linie ablesen (auch Ellbow-Kriterium genannt). Alternativ kann man sich an dem Richtwert von 0.2 orientieren. Unterschreitet das Verhältnis von WSS und BSS diesen Wert, so hat man die beste Lösung gefunden. In diesem Beispiel ist sehr deutlich, dass eine 3-Cluster-Lösung am besten ist.

KmeansObj <- kmeans(Daten, centers = 3, nstart = 20)
plot(DatenAlter, DatenEinkommen, col = KmeansObjcluster, pch = 19, cex = 4,      xlab = "Alter (scaled)",      ylab = "Einkommen (scaled)",      main = "3-Cluster-Lösung") points(KmeansObjcenters, col = 1:3, pch = 3, cex = 5, lwd = 5)

Fazit: Mit K-Means Clustering lassen sich schnell und einfach Muster in Datensätzen erkennen, die, gerade wenn mehr als zwei Variablen geclustert werden, sonst verborgen blieben. K-Means ist allerdings anfällig gegenüber Ausreißern, da Ausreißer gerne als separate Cluster betrachtet werden. Ebenfalls problematisch sind Cluster, deren Struktur nicht kugelförmig ist. Dies ist vor der Durchführung der Clusteranalyse mittels explorativer Datenanalyse zu überprüfen.

R Data Frames meistern mit dplyr – Teil 1

Dieser Artikel ist Teil 1 von 2 aus der Artikelserie R Data Frames meistern mit dplyr.

Data Frames sind das Arbeitspferd von R, wenn Daten in eine Struktur gepackt werden sollen, um sie einzulesen, zu säubern, zu transformieren, zu analysieren und zu visualisieren. Abstrakt gesprochen sind Data Frames nichts anderes als Relationen, also Mengen von Tupels, gebildet aus Elementen von geeigneten Mengen.

Dieses Konzept hat sich auch außerhalb des R-Universums bestens bewährt, umzusammengesetzte Daten, Beobachtungen oder Geschäftsobjekte zu repräsentieren. Der beste Beleg für diese Aussage sind die allgegenwärtigen Relationalen Datenbanksysteme (RDBMS). Dort werden Relationen als Tabellen (Tables) oder Sichten (Views) bezeichnet, und darauf wirkt eine mächtige, imperative Abfrage- und Manipulationssprache namens Structured Query Language, kurz:
SQL.

SQL ist in meiner Wahrnehmung die Lingua Franca der Datenverarbeitung, da sie im Kern über sehr viele Softwareprodukte gleich ist und nach erstaunlich geringem Lernaufwand mächtige Auswerte- und Manipulationsoperationen an den Daten ermöglicht. Hier eine SQL-Anweisung, um eine fiktive Tabelle aller Verkäufe (SALES) nach den Top-10-Kunden in diesem Jahr zu untersuchen:

SELECT customer_id, SUM(sales_amt) AS amount,
COUNT(*) AS n_sales, COUNT(DISTINCT product_id) AS n_products
FROM sales
WHERE sales_date LIKE ’2016-%’
GROUP BY customer_id
ORDER BY SUM(sales_amt) DESC
LIMIT 10

Dieser selbsterklärliche Code aus sieben Zeilen hat einen enormen Effekt: Er fast alle Verkäufe des Jahres 2016 auf Basis der Kundennummer zusammen, berechnet dabei die Summe aller Verkaufsbeträge, zählt die Anzahl der Transaktionen und der verschiedenen vom Kunden gekauften Produkte. Nach Sortierung gemäß absteigenden Umsatzes schneidet der Code nach dem 10. Kunden ab.

SQL kann aber mit der gleichen Eleganz noch viel mehr: Beispielsweise verbinden Joins die Daten mehrerer Tabellen über Fremschlüsselbeziehungen oder analytische Funktionen bestimmen Rankings und laufende Summen. Wäre es nicht toll, wenn R ähnlich effektiv mit Data Frames analoger Struktur umgehen könnte? Natürlich! Aber schon der Versuch, obige SQL-Query auf einem R Data Frame mit den althergebrachten Bordmitteln umzusetzen (subset, aggregate, merge, …), führt zu einem unleserlichen, uneleganten Stück Code.

Genau in diese Bresche springt der von vielen anderen Bibliotheken bekannte Entwickler Hadley Wickham mit seiner Bibliothek dplyr: Sie standardisiert Operationen auf Data Frames analog zu SQL-Operationen und führt zu einer wirklich selbsterklärlichen Syntax, die noch dazu sehr performant abgearbeitet wird. Ganz analog zu ggplot2, das sich an der Grammar of Graphics orientiert, spricht Wickham bei dplyr von einer Grammar of Data Manipulation. Die Funktionen zur Manipulation nennt er folgerichtig Verben.

Dabei treten naturgemäß eine Reihe von Analogien zwischen den Teilen eines SELECT-Statements und dplyr-Funktionen auf:

SELECT-Operation dplyr-Funktion
Bildung der Spaltenliste select()
Bildung eines Ausdrucks mutate()
WHERE-Klausel filter()
GROUP BY Spaltenliste group_by()
Bildung von Aggregaten wie sum() etc. summarise()
HAVING-Klausel filter()
ORDER BY Spaltenliste arrange()
LIMIT-Klausel slice()

Die ersten Schritte

Ich möchte die Anwendung von dplyr mithilfe des Standard-Datensatzes Cars93
aus dem Paket MASS demonstrieren:

> install.packages("dplyr")
> library(dplyr)
> cars <- MASS::Cars93
> str(cars)
’data.frame’: 93 obs. of 27 variables:
$ Manufacturer : Factor w/ 32 levels "Acura","Audi",..: 1 1 2 2 3 ...
$ Model : Factor w/ 93 levels "100","190E","240",..: 49 56 ...

Die erste Aufgabe soll darin bestehen, aus dem Data Frame alle Autos zu selektieren, die vom Hersteller “Audi” stammen und nur Model und Anzahl Passagiere auszugeben. Hier die Lösung in Standard-R und mit dplyr:

> # Standard R: Zu allen Audis das Model, Anzahl Insassen
> subset(cars,Manufacturer=="Audi")[,c("Model","Passengers")]
Model Passengers
3 90 5
4 100 6
>
> # Das gleiche mit dplyr
> select(filter(cars,Manufacturer=="Audi"),Model,Passengers)
Model Passengers
1 90 5
2 100 6

Man sieht, dass die neue Funktion filter() der Zeilenselektion, also der Funktion subset() entspricht. Und die Auswahl der Ergebnisspalten, die in Standard-R durch Angabe einer Spaltenliste zwischen [ und ] erfolgt, hat in dplyr das Pendant in der Funktion select().

select() ist sehr mächtig in seinen Möglichkeiten, die Spaltenliste anzugeben. Beispielsweise funktioniert dies über Positionslisten, Namensmuster und ggf. das auch noch negiert:

select(cars, -starts_with("L")) 

Die obige Abfrage projiziert aus dem Data Frame sämtliche Spalten, die nicht mit “L” beginnen. Das scheint zunächst ein unscheinbares Feature zu sein, zahlt sich aber aus, wenn analytische Data Frames Dutzende oder Hunderte von Spalten haben, deren Bezeichnung sich nach einem logischen Namensschema richtet.
Soweit ist das noch nicht spektakulär. dplyr hilft uns in obigem Beispiel, als erstes bestimmte Datensätze zu selektieren und als zweites die interessierenden Spalten zu projizieren. dplyr ist aber bezüglich der Verarbeitung von Data Frames sehr intuitiv und funktional, sodass wir früher oder später viele Operationen auf unserem Data Frame verketten werden. So erreichen wir die Mächtigkeit von SQL und mehr. Die funktionale Syntax aus dem letzten Beispiel wird dann ganz schnell unleserlich, da die Verabeitungsreihenfolge (zuerst filter(), dann select()) nur durch Lesen des Codes von innen nach außen und von rechts nach links ersichtlich wird.

Daher geht dplyr einen Schritt weiter, indem es den eleganten Verkettungsoperator %>% aus dem magrittr-Paket importiert und zur Verfügung stellt. Dadurch werden die verschachtelten Ausdrücke in Sequenzen von Operationen gewandelt und somit sehr viel lesbarer und wartbarer:

select(filter(cars,Manufacturer=="Audi"),Model,Passengers)
Model Passengers
1 90 5
2 100 6

> cars %>%
+ filter(Manufacturer=="Audi") %>%
+ select(Model,Passengers)
Model Passengers
1 90 5
2 100 6

Diese in meinen Augen geniale Syntax durch den neuen Operator %>% erlaubt einen sequenziellen Aufbau der Operationen auf einem Data Frame. Benutzer der Unix-Kommandozeile werden hier leicht die Analogie zu Pipes erkennen. Ganz abstrakt kann man sagen, dass damit folgende Operationen äquivalent sind:

Traditioneller Funktionsaufruf Verkettung mit %>%
f(a,b) a %>% f(b)
f(a,b,c) a %>% f(b,c)
g(f(a,b),c) a %>% f(b) %>% g(c)

Weiteres erklärt die Dokumentation zum %>%-Operator im Paket magrittr mithilfe
des Befehls ?magrittr::‘%>%‘.

Neue Variablen

Durch die Funtionen select() und filter() können wir aus Data Frames Spalten projizieren und Zeilen selektieren. Ergebnisse neuer Ausdrücke entstehen hingegen mit dem Verb mutate():

> # Mit Umrechnung der Mileage in Verbrauch und des
> # Kaufpreises von USD in EUR
> cars2 <-
+ cars %>%
+ filter(Manufacturer=="Audi") %>%
+ mutate(l_100km = 235 / MPG.city,
+ eur = Min.Price * 1000 / 1.1) %>%
+ select(Model,Passengers,l_100km,eur)
> cars2
Model Passengers l_100km eur
1 90 5 11.75000 23545.45
2 100 6 12.36842 28000.00
> class(cars2)
[1] "data.frame"

Im obigen Beispiel wird zunächst auf den Hersteller Audi selektiert und danach auf einen Streich zwei neue Spalten eingeführt, l_100km und eur. Durch Zuweisen auf eine neue Variable wird das fertige Ergebnis dauerhaft gespeichert. Hierbei handelt es sich wieder um ein natives Data Frame-Objekt. Die Operation transmute() arbeitet analog zu mutate(), verwirft aber nach Bildung der Ausdrücke alle nicht genannten Spalten. Somit können wir obiges Beispiel auch wie folgt schreiben:

cars3 <-
+ cars %>%
+ filter(Manufacturer=="Audi") %>%
+ transmute(Model = Model, Passengers = Passengers,
+ l_100km = 235 / MPG.city,
+ eur = Min.Price * 1000 / 1.1)
cars3
Model Passengers l_100km eur
1 90 5 11.75000 23545.45
2 100 6 12.36842 28000.00

Aggregate

Neben der Selektion von Zeilen und Spalten sowie der Bildung abgeleiteter Ausdrücke ist bei Datenbanktabellen die Gruppierung und Aggregation mit GROUP BY eine sehr wichtige Operation. Dies gilt auch für Data Frames in R, wenngleich hier der Funktionsumfang über diverse Funktionen wie table() oder aggregate() verteilt ist und wenig intuitiv ist.

Hier bringt dplyr ebenfalls eine großartige Verbesserung mit. Das entsprechende Verb heißt group_by(). Diese Operation wird zusammen mit einer Spaltenliste auf ein Data Frame angewendet:

grp_cars <- cars %>% group_by(Manufacturer)
> class(grp_cars)
[1] "grouped_df" "tbl_df" "tbl" "data.frame"

Das Ergebnis von group_by() ist ein Objekt, das “mehr” ist als ein Data Frame, sondern auch noch einige spezifische Strukturinformationen von dplyr enthält. In unserem Beispiel sind dies Indizes von Zeilen, die zum gleichen Hersteller gehören. Das ursprüngliche Data Frame wird hierbei nicht kopiert, sondern nur eingebettet.

Nach Anwenden einer group_by()-Operation ist das Data Frame optimal vorbereitet für die eigentliche Aggregation mit summarise():

> sum_cars <- cars %>%
+ group_by(Manufacturer) %>%
+ summarise(nCars = n(), avg_price = mean(Min.Price))
> str(sum_cars)
Classes ‘tbl_df’, ‘tbl’ and ’data.frame’: 32 obs. of 3 variables:
$ Manufacturer: Factor w/ 32 levels "Acura","Audi",..: 1 2 3 4 5 6 7 8 9 10 ...
$ nCars : int 2 2 1 4 2 8 1 2 6 2 ...
$ avg_price : num 21.1 28.4 23.7 20.8 35.2 ...

Das Resultat von summarise() ist wieder ein Data Frame, das neben den ursprünglichen Gruppierungskriterien nur noch die Aggregate enthält.

Daten in Reih’ und Glied

Zwischen Relationalen Datenbanken und R-Data Frames besteht ein wesentlicher konzeptioneller Unterschied: Die Ergebnisse eines SELECT-Befehls haben keine definierte Reihenfolge, so lange die Zeilen nicht mit der Klausel ORDER BY festgelegt wird. Im Gegensatz dazu haben die Zeilen von Data Frames eine konstante Reihenfolge, die sich aus der Anordnung derWerte in den Spaltenvektoren ergibt.

Dennoch ist es manchmal wünschenswert, Data Frames umzusortieren, um eine fachliche Reihenfolge abzubilden. Hierzu dient in dplyr das Verb arrange(), das im Standard-R weitgehend der Indizierung eines Data Frames mit Ergebnissen der order()-Funktion entspricht, aber syntaktisch eleganter ist:

cars %>%
+ arrange(desc(Horsepower),Manufacturer) %>%
+ select(Manufacturer, Model, Horsepower,Min.Price) %>%
+ slice(1:5)
Manufacturer Model Horsepower Min.Price
1 Chevrolet Corvette 300 34.6
2 Dodge Stealth 300 18.5
3 Cadillac Seville 295 37.5
4 Infiniti Q45 278 45.4
5 Mazda RX-7 255 32.5

Dieses Beispiel hat zum Ziel, die fünf PS-stärksten Autos zu selektieren. Die arrange()-Funktion sortiert hier zunächst absteigend nach der PS-Stärke, dann aufsteigend nach Herstellername. Die Selektion der 5 ersten Zeilen erfolgt mit der hilfreichen Funktion slice(), die aus einem Data Frame Zeilen anhand ihrer Reihenfolge selektiert.

Fazit und Ausblick

Mit dplyr wird die Arbeit mit Data Frames stark verbessert: Im Vergleich zu “nacktem” R bringt das Paket eine klarere Syntax, abgerundete Funktionalität und bessere Performance. In der Kürze dieses Artikels konnte ich dies nur oberflächlich anreissen. Daher verweise ich auf die vielen Hilfe-Seiten, Vignetten und Internet-Videos zum Paket. Im zweiten Teil dieses Artikels werde ich auf einige fortgeschrittene Features von dplyr eingehen, z.B. die Verknüpfung von Data Frames mit Joins, die Window-Funktionen und die Verwendung von Datenbanken als Backend.

Weiter zu R Data Frames meistern mit dplyr – Teil 2.

Die Abschätzung von Pi mit Apache Spark

Auf den Berliner Data Science/Big Data/Data Analytics/…-Meetups auf denen ich in letzter Zeit des Öfteren zugegen war, tauchte immer wieder der Begriff Spark auf. Ich wollte wissen was es hiermit auf sich hat. Nachdem ich Spark 1.5.1 lokal auf meinem Mac installiert hatte, fing ich an Wörter in frei verfügbaren Texten zu zählen. Da es mir aber zu aufwändig schien, extrem lange Texte im Internet zu suchen und ich ein Gefühl für die Leistungsfähigkeit von Spark bekommen wollte, widmete ich mich einem skalierbaren Problem: der Abschätzung von Pi mit der Monte Carlo-Methode.

 1000 Zufallspunkte lokal auf Mac

spark-scala-interface-pi-example

Dies war wie zu erwarten keine Herausforderung für meine Hardware. Was passiert bei 10^6/ 10^7/ 10^8/ 10^9… Zufallspunkten?

dataset-spark-pi-example-1

An dieser Stelle stieß ich auf ein “Integer-Problem“. Weil 3*10^9 > 2^31 – 1, kann in diesem Fall nicht mehr der Datentyp Integer verwendet werden, sondern man müsste „long Integer“ (64 bit) nehmen. Was mich nun jedoch viel mehr interessierte als mit Zufallspunkten > 2^31 – 1  zu experimentieren, war eine Spark-Installation auf AWS und die entsprechenden Berechnungszeiten. Ich installierte Spark 1.5.0 (auf Hadoop 2.6.0 YARN) auf einem AWS-Cluster (2 Core/1 Master x m3.xlarge). Zu meiner Überraschung ergab sich Folgendes:

dataset-spark-pi-example-2

Warum war mein Mac schneller als ein AWS-Cluster? Eine m3.xlarge-Instanz hat 4 Kerne und 15 GB Arbeitsspeicher, mein Mac ziemlich genau die Hälfte… Gut, dann probieren wir das Ganze mal mit einem 4 Core/1 Master x m3.xlarge-Cluster.

dataset-spark-pi-example-3

Es ergibt sich kein signifikanter Unterschied. Erst die Verwendung von einem 3 Core/1 Master x r3.2xlarge-Cluster brachte eine Beschleunigung. Wo ist der Flaschenhals? Um Netzwerkeffekte zu prüfen, habe ich schließlich eine 0 Core/1 Master-AWS-Installation getestet.

dataset-spark-pi-example-4

Dieser letzte Test skalierte zu meinen vorherigen Tests auf dem AWS-System, und er wies darauf hin, dass der Flaschenhals kein Netzwerkeffekt war.

Bei heise Developer fand ich einen sehr interessanten Artikel, welcher sich dem Thema „optimale Konfiguration der virtualisierten Cloud-Hardware für den jeweiligen Anwendungsfall finden“ widmet: Benchmarking Spark: Wie sich unterschiedliche Hardware-Parameter auf Big-Data-Anwendungen auswirken

Für heute belasse ich es bei dem vorgestellten Experiment.

To be continued…,