Geschriebene Artikel über Big Data Analytics

Nico Hezel

KNN: Vorteile und Nacheile

/in , , , , /by

Wie jedes Verfahren haben auch künstliche Neuronale Netzwerke (KNN) ihre Vor- und Nachteile. Im Folgenden sollen einige benannt werden.

Vorteile

  • KNN können bessere Ergebnisse liefern als existierende statistische Ansätze, wenn das Problem ausreichend komplex ist. Das heißt, wenn das Problem nicht linear ist und es viele Eingabedaten mit vielen Variablen gibt.
  • Es gibt zwar sogenannte Hyperparameter, die je nach Einstellung das Netzwerk besser oder schlechter trainieren lassen, diese müssen aber nur manuell geändert werden, wenn neue Rekordwerte erreicht werden sollen. Ansonsten gibt es verhältnismäßig wenige Parameter.
  • Auch für stark nicht lineare Probleme, werden gute Lösungen gefunden. Dazu zählen fast alle Probleme die aus einer Datenbasis stammen, wo menschliche oder andere unvorhersehbare Einflüsse wirken.
  • Für große Datenmengen und viele Datendimensionen (Einflussfaktoren) können sinnvolle Ergebnisse ermittelt werden.

Nachteile

  • Künstliche Neuronale Netzwerke sind oftmals wie eine Blackbox. Dadurch ist es nicht möglich nachzuverfolgen wieso ein Netzwerk eine bestimmte Entscheidung getroffen hat.
  • Damit ein allgemeingültiges gutes Ergebnis berechnet werden kann, bedarf es vieler Beispiel-/Trainingsdaten.
  • Aufgrund der hohen Datenmenge, ist es sinnvoll die Berechnungen auf einer Grafikkarte durchzuführen.
  • Während des Trainings finden sehr viele Gewichtsänderungen in kurzer Zeit statt. Daher ist ein Aufteilen der Arbeit in ein verteiltes System wie Apache Hadoop oder Apache Spark nur schwer möglich und führt oftmals zu drastischen Performanz Einbußen.
  • Ist das Problem mathematisch beschreibbar sind KNNs oftmals schlechter oder maximal genauso gut.
  • Es ist zu keinen Zeitpunkt bekannt ob die gefundene Lösung das globale Optimum ist oder ob es noch bessere Lösungen gibt.

In der Forschung gibt es viele Ansätze um einige der Nachteile aufzuheben.

 

Anne Rozinat & Christian W. Günther

Komplexe Abläufe verständlich dargestellt mit Process Mining

/in , , , , , /by

Stellen Sie sich vor, dass Ihr Data Science Team dabei helfen soll, die Ursache für eine wachsende Anzahl von Beschwerden im Kundenservice-Prozess zu finden. Sie vertiefen sich in die Daten des Service-Portals und generieren eine Reihe von Charts und Statistiken zur Verteilung der Beschwerden auf die verschiedenen Fachbereiche und Produktgruppen. Aber um das Problem zu lösen, müssen die Schwachstellen im Prozess selbst offengelegt und mit dem Fachbereich kommuniziert werden.

Nach Einbeziehen der CRM-Daten sind Sie mit Process Mining schnell in der Lage etliche unerwünschte Schleifen und Verzögerungen im Prozess zu identifizieren. Und diese Abweichungen werden sogar vollautomatisch als graphische Prozesskarte abgebildet! Der Fachbereichsleiter sieht auf den ersten Blick, wo das Problem liegt, und kann umgehend Verbesserungsmassnahmen einleiten.

Genau hier sehen wir eine zunehmende Begeisterung für Process Mining über alle Branchen hinweg: Der Datenanalyst kann nicht nur schnell Antworten liefern sondern auch die Sprache des Prozessmanagers sprechen und die entdeckten Prozessprobleme eindrücklich visuell machen.

Data Scientists bewegen sich geschickt durch eine ganze Reihe von Technologien. Sie wissen, dass 80% der Arbeit in der Aufbereitung und dem Säubern der Daten besteht. Sie können mit SQL, NoSQL, ETL-Tools, Statistik, Skriptsprachen wie Python, Data-Mining-Werkzeugen und R umgehen. Aber für viele von ihnen ist Process Mining noch nicht Teil der Data-Science-Tool-Box. Read more

Benjamin Aunkofer

Auswertung von CSV- und Log-Dateien auf der Command Line mit awk

/in , , /by

Die Programmiersprache awk ist klein und unscheinbar, unter Data Science at the Command Line-Verfechtern allerdings ein häufiges Tool zur schnellen Analyse von CSV-Datein und vergleichbar strukturierten Daten (z. B. Logfiles) mit über Trennzeichen differenzierten Spalten. Auch in Shell-Skripten kommt awk meistens dann zum Einsatz, wenn es um den Zugriff, aber auch um die Manipulation von solchen Dateien geht.

Data Science at the Command Line: Facing the Future with Time-Tested Tools

awk wird als Skriptsprache mit nahezu jeder Linux-Distribution ausgeliefert und ist recht einfach eingehalten, kann jedoch auch schnell kryptisch werden. awk wird meistens ad-hoc auf der Kommandozeile ausgeführt, es können jedoch auch Skripte in awk-Dateien erstellt werden. Häufiger Grund für den Einsatz von awk ist die Anwendung von regulären Ausdrücken (Textmustersuche) auf Logdateien.

Nachfolgend ein kleines Tutorial für den Schnelleinstieg in diese interessante Analysetool auf Kommandozeile. Die CSV-Datei einfach hier downloaden: (einen Überblick über den Inhalt bietet auch eine Einführung in Python, die ebenfalls auf dieser CSV-Datei basiert)

wget https://www.data-science-blog.com/download/standorte.csv

CSV-Datei gedownloaded? Dann kann es losgehen im Terminal jeder beliebiger Linux-Distribution:

awk -F'|' '{print}' standorte.csv

Anweisungen, so auch die obige, beginnen stets mit “awk”. Da diese CSV-Datei nicht mit dem Standardchar (Komma), sondern einem vertikalen Strich (Pipe) getrennt ist, muss dies via “-F’|'” angegeben werden. Wäre das Trennzeichen ein Semikolon, wäre der Parameter “-F’;'” korrekt. Der Befehl gibt jede Zeile des CSV in der Kommandozeile aus, so dass wie nachfolgend den gesamten Dateiinhalt sehen:

ID|Standort|Funktion|Mitarbeiter|Umsatz|Kosten 
1|Muenchen|Verwaltung + Vertrieb|45|3500000|2300000 
2|Stuttgart|Nur Vertrieb|23|2800000|800000 
3|Hannover|Verwaltung + Vertrieb|45|1800000|1000000 
4|Leipzig|Nur Vertrieb|12|1000000|320000 
5|Dresden|Produktio + Vertrieb|65|450000|700000 
6|Frankfurt am Main|Nur Vertrieb|12|240000|20000 
7|Duesseldorf|Nur Vertrieb|43|45000|53000 
8|Kassel|Nur Vertrieb|23|250000|90000 
9|Hamburg|Verwaltung + Vertrieb|89|2800000|690000 
10|Koeln|Nur Vertrieb|21|110000|12000 
11|Potsdam|Nur Vertrieb|12|20000|67000 
12|Nuernberg|Nur Vertrieb|15|60000|30000 
13|Ingolstadt|Nur Vertrieb|8|80000|10000 
14|Wolfsburg|Nur Vertrieb|8|90000|23000 
15|Braunschweig|Nur Vertrieb|32|900000|750000 
16|Augsburg|Verwaltung + Vertrieb|45|700000|370000 
17|Chemnitz|Nur Vertrieb|4|95000|78000 
18|Bochum|Nur Vertrieb|9|32000|67000 
19|Dortmund|Produktio + Vertrieb|56|2100000|450000
20|Essen|Nur Vertrieb|10|190000|140000

Viele CSV- und Logdateien haben keinen Header, diese hier hat jedoch die erste Zeile als Header, die daher bei der Analyse nicht als Werte-Zeile fehlinterpretiert werden darf, daher wird nachfolgend von nun an die Anweisung “NR>1” mitgegeben:

awk -F'|' 'NR>1 {print}' standorte.csv

Spalten werden in awk über das Dollarzeichen angesprochen, folgende Anweisung zeigt uns alle Zeilen der zweiten Spalte:

awk -F'|' 'NR>1 {print $2}' standorte.csv

Diese Skriptsprache beherrscht assoziative Arrays. Es können demnach auch nicht-numerische Schlüssel für den Zugriff auf Datenfelder verwendet werden. Dies machen wir uns für das Anzeigen aller Standorte mit Angabe der jeweiligen Mitarbeiterzahl an dem Standort zu nutze. Die Variable a speichert alle Mitarbeiterzahlen in Spalte 4 über den Schlüssel des Standortnamens in Spalte 2, dann endet der Anweisungsblock und es folgt eine For-Schleife, die alle Schlüsselwerte ausgibt und den dazugehörigen Speicherwert (Mitarbeiterzahl) ausgibt.

awk -F'|' 'NR>1{a[$2] = $4;} END {for (i in a) print "Standort: " i " - Mitarbeiterzahl: " a[i];}' standorte.csv
Standort: Essen - Mitarbeiterzahl: 10
Standort: Bochum - Mitarbeiterzahl: 9
Standort: Hannover - Mitarbeiterzahl: 45
Standort: Frankfurt am Main - Mitarbeiterzahl: 12
Standort: Dresden - Mitarbeiterzahl: 65
Standort: Wolfsburg - Mitarbeiterzahl: 8
Standort: Dortmund - Mitarbeiterzahl: 56
Standort: Braunschweig - Mitarbeiterzahl: 32
Standort: Chemnitz - Mitarbeiterzahl: 4
Standort: Augsburg - Mitarbeiterzahl: 45
Standort: Leipzig - Mitarbeiterzahl: 12
Standort: Duesseldorf - Mitarbeiterzahl: 43
Standort: Nuernberg - Mitarbeiterzahl: 15
Standort: Hamburg - Mitarbeiterzahl: 89
Standort: Muenchen - Mitarbeiterzahl: 45
Standort: Potsdam - Mitarbeiterzahl: 12
Standort: Kassel - Mitarbeiterzahl: 23
Standort: Koeln - Mitarbeiterzahl: 21
Standort: Ingolstadt - Mitarbeiterzahl: 8
Standort: Stuttgart - Mitarbeiterzahl: 23

Auch If-Anweisungen sind einfach machbar. Folgendes Beispiel unterscheidet die Zeilennummern (Spalte1) nach geraden und ungeraden Zahlen und gibt den dazugehörigen Standortnamen (Spalte 2) aus.

awk -F'|' 'NR>1 {if ($1 % 2 == 0) print "Gerade: " $1"->"$2; else print "Ungerade: " $1"->"$2} ' standorte.csv
Ungerade: 1->Muenchen
Gerade: 2->Stuttgart
Ungerade: 3->Hannover
Gerade: 4->Leipzig
Ungerade: 5->Dresden
Gerade: 6->Frankfurt am Main
Ungerade: 7->Duesseldorf
Gerade: 8->Kassel
Ungerade: 9->Hamburg
Gerade: 10->Koeln
Ungerade: 11->Potsdam
Gerade: 12->Nuernberg
Ungerade: 13->Ingolstadt
Gerade: 14->Wolfsburg
Ungerade: 15->Braunschweig
Gerade: 16->Augsburg
Ungerade: 17->Chemnitz
Gerade: 18->Bochum
Ungerade: 19->Dortmund
Gerade: 20->Essen

Folgendes Beispiel klassifiziert alle Standorte mit weniger als 10 Mitarbeitern, allerdings nicht über “if…else…”, sondern über die Kurzabfrage nach dem Schema a>b?”True”:”False”.

awk -F'|' 'NR>1 {a[$2]=$4>=10?$2"->"$4:$2" hat weniger als 10 Mitarbeiter"; print a[$2]}' standorte.csv
Muenchen->45
Stuttgart->23
Hannover->45
Leipzig->12
Dresden->65
Frankfurt am Main->12
Duesseldorf->43
Kassel->23
Hamburg->89
Koeln->21
Potsdam->12
Nuernberg->15
Ingolstadt hat weniger als 10 Mitarbeiter
Wolfsburg hat weniger als 10 Mitarbeiter
Braunschweig->32
Augsburg->45
Chemnitz hat weniger als 10 Mitarbeiter
Bochum hat weniger als 10 Mitarbeiter
Dortmund->56
Essen hat weniger als 10 Mitarbeiter

Folgendes Code-Beispiel zeigt die Zählung der Vorkommnisse (Entsprechung: GROUP BY Spalte3, Count(*)).

awk -F'|' 'NR>1 {a[$3]++;} END {for (i in a) print i, a[i];}' standorte.csv
Produktio + Vertrieb 2
Verwaltung + Vertrieb 4
Nur Vertrieb 14

Etwas umformuliert, können wir auch die Werte pro Gruppe aufsummieren, nachfolgend beispielhaft der Gewinn (Einnahmen aus Spalte 5 – Kosten aus Spalte 6) und die Mitarbeiterzahl über die jeweilige Gruppe.

awk -F'|' 'NR>1{a[$3]+=$5-$6; b[$3]+= $4}END{for (i in a) print i "; Gewinn: " a[i] "; Mitarbeter: " b[i];}' standorte.csv
Produktio + Vertrieb; Gewinn: 1400000; Mitarbeter: 121
Verwaltung + Vertrieb; Gewinn: 4440000; Mitarbeter: 224
Nur Vertrieb; Gewinn: 3452000; Mitarbeter: 232

Das Zusammenführen von Zeichenketten erfolgt simpel durch Aneinandereihung:

c = a b     # Verknüpfung ohne Seperator
c = a";"b   # Verknüpfung mit Semikolon als Seperator
awk -F'|' 'NR>1 {if (a[$3] < $6) a[$3] = $2"->"$6;} END {for (i in a) {print i "->" a[i];}}' standorte.csv
Produktio + Vertrieb->Dresden->700000
Verwaltung + Vertrieb->Muenchen->2300000
Nur Vertrieb->Stuttgart->800000

Ein letztes Beispiel möchte keine einzelnen Zeilen des Datensatzes auflisten und auch keine Gruppierung unterscheiden, sondern die Zusammenfassung über die Angabe der gesamten Mitarbeiteranzahl und der Gewinn-Summe über alle Standorte angeben.

awk -F'|' 'NR>1{x+=$4;y+=$5-$6} END {print "Summe Mitarbeiter: " x " Summe Gewinn: " y}' standorte.csv
Summe Mitarbeiter: 577 Summe Gewinn: 9292000

Fazit

Als Programmiersprache ist awk sicherlich nur ein nice-to-have, aber wenn man das Prinzip dieser Sprache erstmal verstanden hat, kann sie ein interessantes Tool darstellen, um schon auf Kommandozeilenebene sich schnell einen Überblick über Datenbestände zu beschaffen und auch um Datenqualitätstests durchzuführen.

 

Nico Hezel

KNN: Was sind künstliche neuronale Netze?

/in , , , /by

Ein künstliches neuronales Netzwerk (KNN) besteht aus vielen miteinander verbundenen künstlichen Neuronen. Die einzelnen Neuronen haben unterschiedliche Aufgaben und sind innerhalb von Schichten (layer) angeordnet. Sogenannte Netzwerk Topologien geben vor, wie viele Neuronen sich auf einer Schicht befinden und welche Neuronen miteinander vernetzt sind. Neuronale Netze werden im Bereich der künstlichen Intelligenz eingesetzt und sind ein Ansatz im Machine Learning, haben hier jedoch besondere Vor- und Nachteile.

Es gibt drei Schicht- und vier grundlegende Neuronen-Arten. Bei den Schichten wird unterschieden zwischen Eingabe-, Ausgabe- und verborgener Schicht (Visible, Output & Hidden Layer). Alle eingehenden Daten werden an den Eingabe-Neuronen (Visible Unit) in der Eingabeschicht angelegt. Diese wiederum geben die Daten weiter an die verbundenen Ausgabe- oder verborgenen Neuronen (Output, Hidden Unit). Zusätzlich kann in jeder Schicht noch ein Bias Neuron (Bias Unit) zum Einsatz kommen. Read more

Benjamin Aunkofer

Datenvisualisierung in Python [Tutorial]

/in , , , , , /by

Python ist eine der wichtigsten Programmiersprachen in der Data Science Szene. Der Einstieg in diese Programmiersprache fällt zum Beispiel im Vergleich zur Programmiersprache R etwas einfacher, da Python eine leicht zu verstehende Syntax hat. Was jedoch beim Einstieg zur größeren Hürde werden kann, ist der Umgang mit den unüberschaubar vielen Bibliotheken. Die wichtigsten Bibliotheken für Data Science / Data Analytics stellte ich bereits in diesem Artikel kurz vor. Hier ist es wichtig, einfach erstmal anzufangen – Warum nicht mit den ersten Datenvisualisierungen?

Natürlich gibt es sehr viele tolle und schön anzusehende Visualisierungen, die teilweise sehr speziell sind. In einem anderen Artikel stellte ich beispielsweise die 3D-Visualisierung von Graphen mit Python und UbiGraph vor. Dieser Artikel hier gilt aber vor allem Einsteigern, die erste Diagramme hergezaubert bekommen möchten.

Damit wir beginnen können, müssen im Python-Skript zuerst zwei wichtige Bibliotheken eingebunden werden:

import matplotlib.pyplot as pyplot

import pandas as pandas

Beide Bibliotheken können direkt gedownloaded werden, sind aber auch im Anaconda Framework enthalten (Empfehlung: Anaconda für Python 2.7).

Die Bibliothek matplotlib (library) ist mit Sicherheit die gängigste zur Visualisierung von Daten. Die Bibliothek pandas ist eine der verbreitetsten, die für den Zugriff, die Manipulation und Analyse von Daten eingesetzt wird. In diesen einfachsten Beispielen benutzen wir pandas nur zum Zugriff auf Daten.

Für die Visualisierung benötigen wir natürlich auch ein Beispiel-Dataset (Tabelle). Eine solche kann sich jeder selber erstellen, wer die nachfolgenden Code-Beispiele aber nachstellen möchte, kann diese Daten verwenden:

ID|Standort|Funktion|Mitarbeiter|Umsatz|Kosten 
1|Muenchen|Verwaltung + Vertrieb|45|3500000|2300000 
2|Stuttgart|Nur Vertrieb|23|2800000|800000 
3|Hannover|Verwaltung + Vertrieb|45|1800000|1000000 
4|Leipzig|Nur Vertrieb|12|1000000|320000 
5|Dresden|Produktio + Vertrieb|65|450000|700000 
6|Frankfurt am Main|Nur Vertrieb|12|240000|20000 
7|Duesseldorf|Nur Vertrieb|43|45000|53000 
8|Kassel|Nur Vertrieb|23|250000|90000 
9|Hamburg|Verwaltung + Vertrieb|89|2800000|690000 
10|Koeln|Nur Vertrieb|21|110000|12000 
11|Potsdam|Nur Vertrieb|12|20000|67000 
12|Nuernberg|Nur Vertrieb|15|60000|30000 
13|Ingolstadt|Nur Vertrieb|8|80000|10000 
14|Wolfsburg|Nur Vertrieb|8|90000|23000 
15|Braunschweig|Nur Vertrieb|32|900000|750000 
16|Augsburg|Verwaltung + Vertrieb|45|700000|370000 
17|Chemnitz|Nur Vertrieb|4|95000|78000 
18|Bochum|Nur Vertrieb|9|32000|67000 
19|Dortmund|Produktio + Vertrieb|56|2100000|450000
20|Essen|Nur Vertrieb|10|190000|140000

Diese 20 Zeilen können einfach via Copy + Paste in eine Datei kopiert werden, die dann als data-science-blog-python-beispiel.txt abgespeichert werden kann.

Der Zugriff von Python aus erfolgt dann mit pandas wie folgt:

dataset = pandas.read_csv(“data-science-blog-python-beispiel.txt”, sep=”|”, header=0, encoding=”utf8″)

Kreisdiagramm

Ein Kreisdiagramm (Pie Chart) lässt sich basierend auf diesen Daten beispielsweise wie folgt erstellen:

kreisdiagramm

# Pie Chart
var= dataset.groupby(['Funktion']).sum().stack()
temp = var.unstack()
type(temp)
x_list = temp['Mitarbeiter']
label_list = temp.index
pyplot.axis("equal") # Kreisdiagramm rund gestaltet (sonst Standard: oval!)
pyplot.pie(x_list, labels=label_list, autopct="%1.1f%%")
pyplot.title('Aufteilung alle Mitarbeiter auf die Standorte nach Funktion')
pyplot.show()

Balkendiagramm

Balkendiagramme können einfachste Größenverhältnisse aufzeigen.

balkendiagram

var = dataset.groupby('Funktion').Umsatz.sum()
fig = pyplot.figure()
ax = fig.add_subplot(1,1,1)
ax.set_xlabel('Funktion')
ax.set_ylabel('Umsatz in Summe')
ax.set_title('Umsatzvolumen nach Funktion der Filialen')
var.plot(kind='bar')
pyplot.show()

Gestapeltes Balkendiagramm

Mit nur wenig Erweiterung wird aus dem einfachen Balkendiagramm ein gestapeltes.

balkendiagram-gestapelt

var = dataset.groupby(['Funktion', 'Standort']).Umsatz.sum()
var.unstack().plot(kind='bar', stacked=True, grid=True)
pyplot.legend(bbox_to_anchor=(1.09, 1), loc=0, borderaxespad=0.5)
pyplot.show()

Histogramm (Histogram)

Histogramme sind ein wichtiges Diagramm der Statistik, mit dem sich Verteilungen aufzuzeigen lassen.

histogramm

# Histogramm
fig = pyplot.figure()
ax = fig.add_subplot(1,1,1)
ax.hist(dataset['Mitarbeiter'], bins=5, color='#9400D3')
pyplot.title('Mitarbeiter Verteilung')
pyplot.xlabel('Verteilung')
pyplot.ylabel('Anzahl Mitarbeiter')
pyplot.show()

Lininediagramm

Der Beispieldatensatz gibt kein gutes Szenario her, um ein korrektes Liniendiagramm darstellen zu können; aber dennoch hier ein How-To für ein Liniendiagramm:

line-diagam

#Line Chart
var = dataset.groupby('Standort').Umsatz.sum()
fig = pyplot.figure()
ax1 = fig.add_subplot(1,1,1)
ax1.set_xlabel('Umsatz')
ax1.set_ylabel('Standort')
var.plot(kind='line')
pyplot.show()

Kastengrafik (Box Plot)

Ein Box Plot zeigt sehr gut Schwerpunkte in einer Verteilung.

box-plot-diagam

fig = pyplot.figure()
ax = fig.add_subplot(1,1,1)
ax.boxplot(dataset['Mitarbeiter'])
pyplot.show()

Punktverteilungsdiagramm (Scatter Plot)

punktdiagramm

fig = pyplot.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(dataset["Mitarbeiter"], dataset["Umsatz"])
ax.set_xlabel('Anzahl Mitarbeiter')
ax.set_ylabel('Umsatz')
pyplot.show()

Blasendiagramm (Bubble Chart)

Das Punktdiagramm kann leicht durch hinzufügen einer dritten Dimension zu einem Bubble-Chart erweitert werden. In dieser Darstellung mit logarithmischen x-/y-Achsen (log).

bubblechart

fig = pyplot.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(dataset['Kosten'], dataset['Umsatz'], s=dataset['Mitarbeiter'])
ax.set_xlabel('Umsatz')
ax.set_ylabel('Kosten')
pyplot.xscale('log')
pyplot.yscale('log')
pyplot.show()

 

Sven Meyer

Extraktion von Software-Metriken aus Java-Dateien mit ANTLR4

/in , , , /by

In der Software-Entwicklung wird mehr und mehr auf Metriken gesetzt, um den Entwicklungsprozess zu messen und zu verbessern. Tools wie SonarQube und FindBugs helfen dabei – doch sie haben ihre Grenzen. Sie brauchen build-fähige Projekte. Die Metriken sind manchmal nicht genau genug dokumentiert oder lassen sich nur schwer anpassen.

Dabei ist es gar nicht so schwierig, ein eigenes Tool zu schreiben. So können die Metriken selbst definiert, auf Textdateien angewendet, als Skript automatisiert und an beliebige Schnittstellen weitergeben werden – z. B. als CSV-Datei nach R, per Webinterface oder als E-Mail.

Im Folgenden wird gezeigt, wie mit ANTLR4 aus Java-Textdateien Metriken erhoben werden können. Das Beispiel-Projekt steht auf GitHub zur Verfügung.

Statische Code-Analyse mit ANTLR4

ANTLR4 (ANother Tool for Language Recognition) wird seit 1989 von Terence Parr, Professor an der University of San Francisco, entwickelt. Das Tool selbst ist kostenlos; die ausführliche Dokumentation kostet jedoch 27 US-Dollar. Für den Einstieg reicht die kostenlose Dokumentation. ANTLR4 ist eine Java-Bibliothek.

Beim Parsen erstellt ANTLR4 auf Basis einer Grammatik einen Syntaxbaum. Nach dem Parsen wird der Syntaxbaum mit einem Walker abgelaufen. Dabei auftretende Events können über ein Listener-Interface abgefangen werden. Durch das Verarbeiten der Events können eigene Metriken berechnet werden.

Das Listener-Interface selbst wird über die Grammatik spezifiziert. ANTLR4 generiert aus der Grammatik Listener in Java, von denen anschließend geerbt wird.

Für viele Programmiersprachen gibt es bereits fertige Grammatiken, die auf GitHub gemeinsam entwickelt werden (siehe z. B. Java-Grammatik). Ansonsten muss die Grammatik selbst geschrieben werden.

Das Beispiel-Projekt

Im Beispiel wird der Klassenname und die Anzahl von Methoden aus einer Java-Klasse erhoben:

/**
 * A cat is a cat is a cat.
 *
 */

public class Cat {

      private String name;

      private int height;

      public Cat(String name, int height) {

            setName(name);

            setHeight(height);

      }

      public String getName() {

            return name;

      }

      public void setName(String name) {

            this.name = name;

      }

      public int getHeight() {

            return height;

      }

      public void setHeight(int height) {

            this.height = height;

      }
}

Das Ergebnis wird in einer Map<String, Integer> ausgegeben.

Vorbereitungen

Im Beispiel werden Eclipse, ein ANTLR4-Eclipse-Plugin und Maven benutzt. ANTLR4 lässt sich auch unabhängig von Eclipse und Maven benutzen.

Nach der Installation des Eclipse-Plugins muss in der pom.xml eine Dependency ergänzt werden:

<dependency>

<groupId>org.antlr</groupId>

<artifactId>antlr4-maven-plugin</artifactId>

<version>4.5</version>

</dependency>

Die Java-Grammatik wird von GitHub heruntergeladen und unter src/main/antlr4/Java.g4 abgelegt. Anschließend werden per Rechtsklick auf Java.g4 -> Run As -> Generate ANTLR Recognizer die Hilfsdateien von ANTLR4 angelegt.

Damit die Hilfsdateien von Eclipse als Java-Quellcode erkannt werden, werden sie nach src/main/java/generated kopiert.

Metriken definieren

ANTLR4 erstellt aus der Grammatik einen JavaBaseListener. Zum Definieren der Metriken wird ein eigener Listener programmiert, der vom JavaBaseListener erbt. Wenn ANTLR4 später den Syntaxbaum durchläuft, ruft es die entsprechenden Listener-Methoden auf.

/**
* Listens to Events, if ANTLR walks a parse tree.
*
* @author Sven Meyer
*/

public class Listener extends JavaBaseListener {

Im JavaBaseListener sind alle Events, auf die gehört werden kann, als Methode aufgeführt. Um nun den Klassennamen für die Metrik zu erfahren, wird das Event ClassDeclaration abgehört:

/** Listen to matches of classDeclaration */

@Override

public void enterClassDeclaration(JavaParser.ClassDeclarationContext ctx) {

setClazzName(ctx.Identifier().toString());

}

Um die Anzahl der Methoden zu erhalten, wird ein Counter bei jedem Auftreten einer MethodDeclaration erhöht.

/** Listen to matches of methodDeclaration */

@Override

public void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx) {

methodCount++;

}

ANTLR ausführen

Damit ANTLR ausgeführt werden kann, braucht es noch die zu lesende Datei und den Listener. Dazu sind nur wenige Zeilen Code notwendig:

public Map<String, Integer> extract(File importFile) throws Exception {

/** Prepare input for ANTLR. */

InputStream is = new FileInputStream(importFile.getAbsolutePath());

ANTLRInputStream input = new ANTLRInputStream(is);

JavaLexer lexer = new JavaLexer(input);

CommonTokenStream tokens = new CommonTokenStream(lexer);

JavaParser parser = new JavaParser(tokens);



/** Parse. */

ParseTree tree = parser.compilationUnit();



/** Create standard walker. */

ParseTreeWalker walker = new ParseTreeWalker();



/** Initiate walk of tree with listener. */

Listener listener = new Listener(parser);

walker.walk(listener, tree);



/** Save the results. */

Map<String, Integer> result = new HashMap<>();

result.put(listener.getClazzName(), listener.getMethodCount());

Ein Test prüft, ob der Klassenname und die Methodenanzahl richtig extrahiert werden:

@Test

public void test() throws Exception {

/** Prepare. */

// String = clazzName, Integer = methodCount

Map<String, Integer> result = new HashMap<>();



/** Execute. */

Extractor e = new Extractor();

result = e.extract(new File("src/main/resources/Cat.java"));



/** Test. */

// clazzName should be Cat

assertTrue(result.keySet().contains("Cat"));

// count of methods should be 4

assertEquals(new Integer(4), result.get("Cat"));

}

Die fertige Projektstruktur sieht in Eclipse so aus:

01_projektstruktur

Abbildung 1: Die fertige Projektstruktur.

Nun kann der Test erfolgreich durchgeführt werden.

02_erfolgreicher_test

Abbildung 2: Der Testfall läuft erfolgreich.

 Fazit

Damit der Code produktiv genutzt werden kann, sollten noch mögliche I/O- und ANTLR-Fehler behandelt werden. Außerdem müssen die erhobenen Daten weitergegeben werden, um z. B. als CSV-Datei in R importiert werden zu können.

Erfahrungsgemäß ergeben sich aus dem großen Sprachumfang viele Sonderfälle, die bei der Definition von Metriken berücksichtigt werden müssen. Hier helfen Testfälle weiter, um eine korrekte Messung sicherzustellen.

Das Beispiel konnte zeigen, dass leicht eigene Metriken aus Java-Quellcode erhoben werden können. So werden Quellcode und strukturierte Texte für die Analyse und Optimierung zugänglich.

 

Referenzen & Links

  • ANTLR4
    Die Projektseite von ANTLR4.
  • Java-Grammatik
    Die ANTLR4-Grammatik für die Java-Programmiersprache.
  • Beispielprojekt auf GitHub
    Das in diesem Tutorial verwendete Beispielprojekt auf GitHub.
  • ANTLR4-Eclipse-Plugin
    Das Eclipse-Plugin, das zum Ausführen von ANTLR4 in Eclipse benutzt werden kann.
  • Rascal MPL
    Eine Meta-Programmiersprache. Erlaubt nicht nur die Analyse, sondern auch das Erzeugen + Verändern von Quellcode.
  • Fallstudie Java-Korpus
    Eine laufende Fallstudie des Autors, in der ANTLR4 benutzt wird, um die typische Verwendung von Java-Sprachkonstrukten in 2,8 Mio. Dateien zu untersuchen.
Dieter Gennburg

R für Process Mining & Projektmanagement – Literaturempfehlungen

/in , , , /by

Es gibt immer wieder Skriptsprachen, die neu am IT-Horizont geboren um Anwender werben. Der IT-Manager muß also stets entscheiden, ob er auf einen neuen Zug aufspringt oder sein bisheriges Programmierwerkzeug aktuellen Anforderungen standhält. Mein Skriptsprachenkompass wurde über frühere Autoren kalibriert, an die hier erinnert werden soll, da sie grundsätzliche Orientierungshilfen für Projektplanungen gaben.

Im Projektmanagement geht es stets um aufwandsbezogene Terminplanung, im CAFM-Projektmanagement  z. B. konkret um die Analyse und Schätzung geplanter und ungeplanter Maßnahmen, wie geplante Wartungen oder zufällige technische Störungen im Gebäudemanagement, um Wahrscheinlichkeiten.

Warum löst R die Terminplanung strategisch und praktisch besser als Python, Perl, Java oder etc.? Weil sich geschätzte Ereignisse in Zeitfenstern normalverteilt als so genannte Gaußsche Glockenkurve abbilden, einer statistischen Schätzung entsprechen.

Hier zwei Beispielgrafiken zum Thema Terminschätzung aus aktueller Literatur.

1. Standardnormalverteilung

Praxishandbuch Projektmanagement – inkl. Arbeitshilfen online von Günter Drews, Norbert Hillebrand, Martin Kärner, Sabine Peipe, Uwe Rohrschneider

Haufe-Lexware GmbH & Co. KG, Freiburg, 1. Auflage 2014 – Siehe z. B. Seite 241, Abb. 14 Normalverteilung als Basis von PERT (Link zu Google Books)


Praxishandbuch Projektmanagement – inkl. Arbeitshilfen online

2. Betaverteilung

Projektmanagement für Ingenieure: Ein praxisnahes Lehrbuch für den systematischen Projekterfolg von Walter Jakoby, Hochschule Trier

Springer Vieweg, Springer Fachmedien Wiesbaden 2015, 3, Auflage – Siehe z. B. Seite 215, Abb. 7.13 Beta-Verteilung (Link zu Google Books).


Projektmanagement für Ingenieure: Ein praxisnahes Lehrbuch für den systematischen Projekterfolg 

Eine objektorientierte Statistikprogrammiersprache mit über 7.000 Paketen weltweit lädt ein, nicht jede Funktion neu erfinden zu wollen und macht glaubhaft, dass kein Unternehmen der Welt über derart Programmierwissen und Kapazität verfügt, es besser zu können. Für statistische Berechnungen empfiehlt sich seit Jahren R, für mich spätestens seit 2003. Früheren Autoren war das grundlegend klar, daß deterministische Terminplanungen immer am Mangel stochastischer Methoden kranken. In meiner Studienzeit kursierte an der Martin Luther Universität Halle an der Saale der Witz, es gibt zwei Witze an der landwirtschaftlichen Fakultät, den Badewitz und den Howitz.  Doch das Buch vom Badewitz halte ich bis heute. Im Kapitel 5.3 Elemente der Zeitplanung fand ich dort in Abbildung 5.7 auf Seite 140 erstmals die Wahrscheinlichkeitsverteilung einer Vorgangsdauer als normalverteilte Grafik.

Vgl. Zur Anwendung ökonomisch-mathematischer Methoden der Operationsforschung, federführend Dr. sc. agr. Siegfried Badewitz, 1. Auflage 1981, erschienen im VEB Deutscher Landwirtschaftsverlag Berlin. Ein Grafikkünstler zur schnellen Visualisierung von Funktionen und Dichteverteilungen ist seit Jahren R. Zur R-Umsetzung empfehle ich gern meine R-Beispielbibel bei Xing.

Wer zur Statistik der Terminschätzung tiefer greifen will, kommt an Autoren wie Golenko u. a. nicht vorbei. Badewitz verwies z.B. auf Golenko’s Statistische Methoden der Netzplantechnik in seinem o.g. Buch (Link zu Google Books).


Statistische Methoden der NetzplantechnikHier empfehle ich zum Einstieg das Vorwort, das 2015 gelesen, aktuell noch immer gilt, nicht das Jahr seiner Niederschrift 1968 preisgibt:

Gegenwärtig beobachtet man häufig Situationen, in denen bei der Untersuchung von zufallsbeeinflußten Systemen die in ihnen auftretenden Zufallsparameter durch feste Werte (z. B. den Erwartungswert) ersetzt werden, wonach dann ein deterministisches Modell untersucht wird.

Und hier noch ein Beispiel von Seite 203:

Praktisch kann jede komplizierte logische Beziehung auf eine Kombination elementarer stochastischer Teilgraphen zurückgeführt werden.

Meine Empfehlung für Process Mining und Projektmanagement lautet daher – intelligente Stochstik statt altbackenem Determinismus.

 

Benjamin Aunkofer

3D-Visualisierung von Graphen

/in , , , /by

Die Graphentheorie ist ein wichtiger Teil vieler Methoden und Anwendungsgebiete für Big Data Analytics. Graphen sind mathematisch beschreibbare Strukturen, ohne die im Ingenieurwesen nichts funktionieren würde. Ein Graph besteht aus zwei Knoten (Ecken, engl. Vertex), die über eine Kante (engl. Edge) verbunden sind.

Auf Graphen stoßen Data Scientists beispielsweise bei der Social Media Analyse, beim Aufbau von Empfehlungssystemen (das Amazon-Prinzip) oder auch bei Prozessanalysen (Process Mining). Aber auch einige Big Data Technologien setzen ganz grundlegend auf Graphen, beispielsweise einige NoSQL-Datenbanken wie die Graphendatenbank Neo4j und andere.

Graphen können nicht nur einfache Verkettungen, sondern komplexe Netzwerke abbilden. Das Schöne daran ist, dass Graphen nicht ganz so abstrakt sind, wie viele andere Bereiche der Mathematik, sondern sich wunderbar visualisieren lassen und wir auch in unserem Vorstellungsvermögen recht gut mit ihnen “arbeiten” können.

ubigraph-node-visualization2

Mit der Visualisierung von Graphen, können wir uns Muster vor Augen führen und ein visuelles Data Mining betreiben. Iterative und auch rekursive Vorgänge sowie Abhängigkeiten zwischen einzelnen Objekten/Zuständen können visuell einfach besser verstanden werden. Bei besonders umfangreichen und zugleich vielfältigen Graphen ist eine Visualisierung in drei bzw. vier Dimensionen (x-, y-, z-Dimensionen + Zeit t) nicht nur schöner anzusehen, sondern kann auch sehr dabei helfen, ein Verständnis (z. B. über Graphen-Cluster) zu erhalten. Read more

Benjamin Aunkofer

Aus der Datenflut das Beste machen – Zertifikatskurs „Data Science“ in Brandenburg

/in , , , , , /by

Die Aufbereitung von Daten, ihre Analyse und Darstellung sind mittlerweile zu einer Wissenschaft für sich geworden – „Data Science“. Unternehmen sehen sich heute unabhängig von ihrer Größe von einer Vielzahl unterschiedlicher Daten herausgefordert: Neben klassischen Transaktionsdaten stehen heute z.B. Daten aus der Logistik (RFID, GIS), aus sozialen Medien, dem Internet der Dinge oder öffentlichen Quellen (Open Data / Public Data) zur Verfügung. Ein neuer Zertifikatskurs Data Science ermöglicht jetzt eine wissenschaftliche Weiterbildung zur Nutzung von Daten als „Rohstoff des 21. Jahrhunderts“.

Die Agentur für wissenschaftliche Weiterbildung und Wissenstransfer (AWW e.V.) bietet in Kooperation mit der Fachhochschule Brandenburg den berufsbegleitenden Zertifikatskurs mit nur wenigen Präsenzphasen ab Oktober an. Die wissenschaftliche Leitung hat Dr. Peter Lauf übernommen, ein erfahrener Praktiker, der zurzeit noch eine Professur für Quantitative Methoden und Data Mining an der Hochschule für Technik und Wirtschaft Berlin vertritt. Zertifiziert wird der Abschluss Data Scientist (FH).

Die Weiterbildung hat nur wenige Präsenzphasen an Freitagen und Samstagen und ist daher für Teilnehmer/innen aus dem ganzen Bundesgebiet geeignet – So kommen einige Teilnehmer auch aus Frankfurt am Main und München.

Wer sich schnell entscheidet, kann bis 16. Juli 2015 vom Frühbucherrabatt profitieren!

Der Inhalt des Kurses orientiert sich an einer bekannten Einteilung des amerikanischen Wirtschaftswissenschaftlers und Google-Chefökonomen Hal Varian: Ihm zufolge setzt sich die spezifische Wertschöpfungskette von Daten aus Zugriff, Verständnis, Verarbeitung, Analyse und Ergebniskommunikation zusammen. Data Science umfasst deshalb die Module Data Engineering (Zugriff, Verständnis, Verarbeitung), Quantitative Methoden und Data Mining (Analyse) sowie Storytelling: Kommunikation und Visualisierung der Ergebnisse (Ergebniskommunikation).

Die Weiterbildung vereinigt damit Fachwissen aus der Informatik mit quantitativen Methoden und Aspekten des Informations- und Kommunikationsdesigns. Wichtige Werkzeuge im Kurs sind die Statistiksprache R und Power Business Intelligence Tools. Auch auf Azure Machine Learning wird mit konkreten Beispielen Bezug genommen. Im Ergebnis sollen die Teilnehmer verschiedene Techniken zur Nutzung von Daten beherrschen und einen Überblick über die Voraussetzungen und möglichen Lösungsansätze im Bereich datengetriebener Projekte erhalten. Lernziel ist die reibungslose Kommunikation zwischen Management, Engineering und Administration.

Weitere Auskünfte erteilt Katja Kersten (Tel. 03381 – 355 754, E-Mail: katja.kersten@fh-brandenburg.de). Nähere Informationen im Internet sind unter www.aww-brandenburg.de erhältlich.

Sven Galonska

Flexible ABC Analyse mit Excel Power Pivot und DAX

/in , , , /by

Eine klassische Methode im Bereich des Controllings ist sicherlich die ABC-Analyse, auch Paretoprinzip oder 80/20-Regel genannt. Das Paretoprinzip beschreibt ein statistisches Phänomen, bei dem eine kleine Anzahl hoher Werte (Kategorie A)  mehr zum Gesamtwert beiträgt als eine große Anzahl kleiner Werte (Kategorie C). Vilfredo Pareto (1848 – 1923)  entdeckte dieses Prinzip, als er die Bodenverteilung in Italien untersuchte. Er fand heraus, daß ca. 20 % der Bevölkerung ca. 80 % des Bodenbesitzes besitzen.

Im Folgenden soll mit Hilfe von Excel Power Pivot (ein Mitglied der Microsoft Power BI Familie) und DAX Formeln (Data Analysis Expressions) ein Weg aufgezeigt werden, wie eine flexible ABC-Analyse (Materialgruppenübergreifend oder je Materialgruppe) auf Basis von Artikelumsätzen (Einkaufsvolumen, EVO) realisiert werden kann. Dabei werden die Artikel mit den Kategorien A (80 %), B (15%) sowie C (5%) im Modell gekennzeichnet, so daß Anzahl Artikel und Umsätze (EVO) bei Bedarf aggregiert nach Materialgruppe dargestellt werden können.

„Aber das kann ich doch mit der Pivottabelle auch schon machen!“ werden Sie jetzt vielleicht sagen. Richtig ist, daß man mit der klassischen Pivottabelle den kumulierten Anteil in % ausweisen kann. Dazu muß ein Wertfeld lediglich über die Wertfeldeinstellungen, Reiter „Werte anzeigen als“ auf die Option „% von Ergebnis in“ umgestellt werden. Soweit so gut, nur was ist mit der Zuweisung der Klasse A, B, C? Wie kann man nach der Klassifizierung gruppieren? Und weiter, wie stellt man die Anzahl der Artikel nicht als einzelne Elemente sondern als Aggregat dar?

excel-abc-analyse-1 Read more