Daten in Formation bringen

Bei den vielfach stattfindenden Diskussionen um und über den Begriff Big Data scheint es eine Notwendigkeit zu sein, Daten und Informationen gegeneinander abzugrenzen. Auf Berthold Brecht geht folgendes Zitat zurück: „Ein Begriff ist ein Griff, mit denen man Dinge bewegen kann“. Folgt man dieser Aussage, so kann man leicht die falschen Dinge bewegen, wenn man die Begriffe nicht im Griff hat.
Eine mögliche Herangehensweise zur Unterscheidung der Begriffe Daten und Informationen liefert dabei die Semiotik (Zeichentheorie), welche in Syntax, Semantik und Pragmatik untergliedert werden kann:

Unter Syntax (altgr.: Ordnung, Reihenfolge) versteht man im Allgemeinen Regeln, welche es erlauben, elementare Zeichen zu neuen, zusammengesetzten Zeichen, Worten und Wortgruppen zu kombinieren. Daten sind tendenziell diesem Bereich zuzuordnen.

Beispiel:    10:30    24    Essen

Die Semantik (griech.: bezeichnen, zum Zeichen gehörend, auch Bedeutungslehre) indes beschäftigt sich mit Beziehungen und Bedeutung von Zeichen (Kontext). Regeln der Zusammensetzung aus der Syntax stehen demnach den Interpretationsregeln der Semantik gegenüber. Mit anderen Worten, der Kontext (Bezugsrahmen), in welchem die Zeichen verwendet werden, bestimmt deren Bedeutung. Ludwig Wittgenstein (1889 – 1951) verglich Worte mit Schachfiguren und postulierte, dass die Verwendung eines Wortes dessen Bedeutung bestimmt.

Beispiel:    10:30 Uhr    24 Grad Celcius    Stadt Essen

Pragmatik wiederum beschäftigt sich mit dem Gebrauch von Worten und somit der Verwendung von Sprache in spezifischen Situationen. Bei Informationen stehen dabei Handlungsorientierung sowie subjektiver Nutzen im Vordergrund. Informationen reduzieren Unsicherheit beim Empfänger, sie bereiten eine Entscheidung vor.

Beispiel: Auf Grund der Temperatur in der Stadt Essen um 10:30 Uhr benötige ich keine Jacke

Abbildung 1 Daten versus Informationen, eigene Darstellung

Abbildung 1 Daten versus Informationen, eigene Darstellung

Fazit:

(Big) Daten sind eine notwendige, aber keine hinreichende Bedingung für die Bildung von entscheidungsrelevanten Informationen. In anderen Worten, Daten sind vergleichbar mit Ziegelsteinen. Wenn man aus Ziegelsteinen (Daten) kein Haus (Kontext, Informationen) baut, sind es bloß Ziegelsteine. Man kann Informationen wiederum als Rohstoff interpretieren, aus welchem Entscheidungen hergestellt werden (können).

Text-Mining mit dem Aika Algorithmus

In diesem Beitrag möchte ich das Open Source Projekt Aika vorstellen. Ziel des Projektes ist es einen Text-Mining Algorithmus zu entwickeln, der ein künstliches Neuronales Netz (kNN) mit einem Pattern Mining Algorithmus kombiniert. Dabei dient die Silbentrennung von Wörtern als initiale Aufgabe, anhand derer der Algorithmus weiterentwickelt wird. Für diese Aufgabe soll allerdings kein vordefiniertes Wörterbuch verwendet werden. Stattdessen sollen die Silben in ihrer Eigenschaft als häufig auftretende Muster in rohem Text erkannt werden. Hier reicht es allerdings nicht einen Mining Algorithmus nach häufig auftretenden Strings suchen zu lassen, da sich viele der Strings überlappen oder schlicht keinen Sinn ergeben würden. Es ist also wichtig, dass sich die erkannten Silben gegenseitig unterdrücken können und dass der Algorithmus in der Lage ist, die so entstehenden unterschiedlichen Interpretationen eines Wortes miteinander zu vergleichen und die am höchsten gewichtete auszuwählen. Beispielsweise taucht die Silbe ‘der’ zu Beginn des Wortes ‘de-re-gu-lie-ren’ auf. In diesem Fall muss der Algorithmus erkennen, dass die erste Silbe des Wortes nicht ‘der’ sondern nur ‘de’ ist.

Wenn nun nach häufig auftretenden Mustern in Text gesucht werden soll, warum verwenden wir nicht einen reinen Pattern Mining Algorithmus? Der Grund für die Kombination mit einem kNN liegt darin, dass die erkannten Muster innerhalb einer kNN Topologie aufeinander aufsetzen können. Wenn z. B. das Wort “hausboot” als Muster erkannt werden soll, dann entstünden in der Datenstruktur des Mining Algorithmus sehr viele Teilmuster, die alle evaluiert werden müssten. Viel leichter wäre es für den Algorithmus, wenn die Muster “haus” und “boot” bereits erkannt worden wären und nun als Eingaben für die Erkennung des Wortes “hausboot” dienen könnten. So ist der Algorithmus zum einen in der Lage komplexere Muster zu erkennen und muss gleichzeitig weniger Teilmuster untersuchen. Ausserdem erlaubt es ein kNN ‘weiche’ Muster zu erlernen, also Muster bei denen einzelne Eingänge optional sind, die aber trotzdem noch sicher erkannt werden. Dadurch kann eine höhere Toleranz gegenüber Fehlern erreicht werden.

Im Gegensatz zu einem klassischen kNN nutzt Aika einen eher mit Googles Pagerank vergleichbaren Ansatz um Gewichte zwischen den einzelnen Neuronen des Netzwerks zu propagieren. Der Grutext-pattern-knnndgedanke dabei ist es, dass Neuronen entsprechend höher gewichtet werden sollten, wenn sie mit anderen hoch gewichteten Neuronen in Beziehung stehen. Wenn also beispielsweise eine Silbe in vielen hoch gewichteten Worten auftaucht, wird sie selbst entsprechend höher gewichtet.

Neuronen eines kNN erlauben es aber nicht nur Konjunktionen wie etwa bei Mustern zu erlernen, sondern auch Disjunktionen. Disjunktionen sind insbesondere beim Erlernen von Grammatikregeln wichtig, wenn z. B. einzelne Worte als Nomen erkannt werden sollen. Wenn nun solche Disjunktionen erlernt werden sollen, können auch hier häufige Muster behilflich sein. Angenommen, es wurden durch den Mining Algorithmus bereits die folgenden häufigen Muster gefunden: “der Baum” (f=4), “der Hammer” (f=3) und “der Nagel” (f=6). Dann können diese Muster so umgeformt werden, dass ein neues, deutlich häufigeres Muster “der <NOMEN>” (f=13) und eine Disjunktion <NOMEN> = “Baum” oder “Hammer” oder “Nagel”, entsteht.

Die üblichen Verdächtigen – 8 häufige Fehler in der Datenanalyse

Das eine vorab: eine Liste der meist begangenen Fehler in der Datenanalyse wird in jedem Fall immer eine subjektive Einschätzung des gefragten Experten bleiben und unterscheidet sich je nach Branche, Analyse-Schwerpunkt und Berufserfahrung des Analysten. Trotzdem finden sich einige Missverständnisse über viele Anwendungsbereiche der Datenanalyse hinweg immer wieder. Die folgende Liste gibt einen Überblick über die acht am häufigsten begangenen Fehler in der angewandten Datenanalyse von denen ich behaupte, dass sie universell sind.

  1. Statistische Signifikanz versus Relevanz

Die Idee der statistischen Signifikanz wird oft missverstanden und deswegen fälschlicherweise mit statistisch belegter Relevanz gleichgesetzt. Beide messen jedoch sehr unterschiedliche Dinge. Statistische Signifikanz ist ein Maß der Gewissheit, welches die Zufälligkeit von Variation berücksichtigt. „Statistisch signifikant“ bedeutet also, dass es unwahrscheinlich ist, dass ein bestimmtes Phänomen nur zufällig auftritt. „Statistisch nicht signifikant“ bedeutet, dass neben der zufälligen Variation keine systematische bewiesen werden konnte. Wichtig: dies bedeutet nicht, dass es keine Effekte gibt, sondern, dass diese nicht belegt werden konnten. Statistische Signifikanz lässt sich mit ausreichend vielen Beobachtungen allerdings auch für sehr kleine Unterschiede belegen. Generell gilt: je größer die Stichprobe, desto kleiner werden die Unterschiede, welche als statistisch signifikant getestet werden. Deswegen unterscheidet sich die statistische Relevanz von der statistischen Signifikanz.

Statistische Relevanz misst hingegen die Effektstärke eines Unterschiedes. Die Größe eines Unterschiedes wird dazu in Relation zur Streuung der Daten gesetzt und ist damit unabhängig von der Stichprobengröße. Je größer die Varianz der Zufallsvariablen, desto kleiner wird die Effektstärke.

  1. Korrelation versus Kausalität

Wird eine hohe Korrelation zwischen zwei Größen festgestellt, so wird oft geschlussfolgert, dass eine der beiden Größen die andere bestimmt. In Wahrheit können auch komplexe statistische und ökonometrische Modelle keine Kausalität beweisen. Dies gilt sogar, wenn die Modellierung einer theoretischen Grundlage folgt, denn auch die kann falsch sein. Regelmäßig lehnen sich Forscher und Analysten aus dem Fenster, indem sie Wirkungen behaupten, welche eine genaue Prüfung nicht aushalten. Standardfragen, die als Automatismus einer jeden Analyse folgen sollte, welche behauptet Effekte gefunden zu haben sind: Welche Rolle spielen unbeobachtete Heterogenitäten, umgekehrte Kausalität und Messfehler in den Variablen für das Schätzergebnis? Erst wenn diese drei Quellen von Endogenität kontrolliert werden und außerdem davon ausgegangen werden kann, dass die Stichprobe die Grundgesamtheit repräsentiert, kann ein kausaler Zusammenhang angenommen und quantifiziert werden.

  1. Unbeobachtete Einflussfaktoren

Nicht messbare und deswegen nicht erhobene Einflüsse verzerren die geschätzten Parameter der kontrollierbaren Faktoren, sofern letztere mit den unbeobachteten im Zusammenhang stehen. In anderen Worten: der geschätzte Effekt wird fälschlicherweise der beobachteten Größe zugeschrieben, wenn eigentlich eine dritte, nicht beobachtete Größe die Zielgröße bedingt und gleichzeitig mit der beobachteten Größe korreliert. Das Lehrbeispiel
für Verzerrungen durch unbeobachtete Größen ist die Lohngleichung – eine Gleichung die seit nunmehr 60 Jahren intensiv beforscht wird. Die Schwierigkeit bei der Quantifizierung des Effektes von Ausbildung liegt darin, dass die Entlohnung nicht nur über Alter, Berufserfahrung, Ausbildung und den anderen Kontrollvariablen variiert, sondern auch durch das unterschiedlich ausgeprägte Interesse an einem lukrativen Erwerb und die Fähigkeit des Einzelnen, diesen zu erlangen. Die Herausforderung: es gibt keinen statistischen Test, welche eine Fehlspezifikation durch unbeobachtete Größen angibt. Unabdingbar ist deswegen ein tiefgehendes Verständnis des Analyseproblems. Dieses befähigt den Analysten Hypothesen zu formulieren, welche unbeobachteten Größen über eine Korrelation mit dem getesteten Regressor im Fehlerterm ihr Unwesen treiben. Um Evidenz für die Hypothesen zu schaffen, müssen smarte Schätzdesigns oder ausreichend gute Instrumente identifiziert werden.statistische-verzerrung

  1. Selektionsverzerrung

Eine Selektionsverzerrung liegt vor, wenn Beobachtungen nicht für jedes Individuum vorliegen oder von der Analyse ausgeschlossen werden. Die Grundvoraussetzung für jeden statistischen Hypothesentest ist die Annahme einer Zufallsstichprobe, so dass die Zielpopulation repräsentativ abgebildet ist. In der Praxis ergeben sich allerdings oft Situationen, in denen bestimmte Merkmale nur für eine Gruppe, aber nicht für eine zweite beobachtet werden können. Beispielsweise kann der Effekt einer gesundheitsfördernden Maßnahme eines Großbetriebes für die gesamte Belegschaft nicht durch die freiwillige Teilnahme einiger Mitarbeiter gemessen werden. Es muss explizit dafür kontrolliert werden, welche Unterschiede zwischen Mitarbeitern bestehen, welche das Angebot freiwillig in Anspruch nehmen im Vergleich zu denen, die es nicht annehmen. Eine Gefahr der Über- oder Unterschätzung der Effekte besteht generell immer dann, wenn über die Beschaffenheit der Stichprobe im Vergleich zur Grundgesamtheit nicht nachgedacht wird. Auf Basis einer nicht repräsentativen Stichprobe werden dann fälschlicherweise Generalisierungen formuliert werden, welche zu falschen Handlungsempfehlungen führen können.

  1. Überanpassung und hohe Schätzervarianz

Überanpassung passiert, wenn der Analyst „zu viel“ von den Daten will. Wird das Model überstrapaziert, so erklären die Kontrollvariablen nicht nur die Zielgröße sondern auch das weiße Rauschen, also die Zufallsfehler. Die Anzahl der Regressoren im Verhältnis zur Anzahl der Beobachtungen ist in solch einer Spezifikation übertrieben. Das Problem: zu wenig Freiheitsgrade und das vermehrte Auftreten von Multikollinearität führen zu einer hohen Varianz in der Verteilung der Schätzer. Ein Schätzergebnis einer Spezifikation mit einer hohen Schätzervarianz kann also Schätzergebnisse produzieren, welche vom wahren Wert weiter entfernt sind als ein verzerrter Schätzer. Tatsächlich ist ein „falsches“ meistens ein Hinweis auf Multikollinearität.verlorene-effizienz-statistisches-modell

Oft macht es Sinn, die Spezifikation anzupassen, indem man die korrelierten Regressoren ins Verhältnis zueinander zu setzt. In der Praxis geht es immer darum, einen Kompromiss aus Verzerrung und Varianz zu finden. Das Kriterium hierfür ist die Minimierung des mittleren quadratischen Fehlers. Um zu überprüfen, ob der Analyst über das Ziel hinausgeschossen ist, gibt es zudem verschiedene Validierungsmethoden, welche je nach Methode einen bestimmten Anteil oder sogar keine Daten „verschwenden“, um das Modell zu überprüfen.kompromiss-quadratischer-fehler-statistisches-modell

  1. Fehlende Datenpunkte

Beobachtungen mit fehlenden Datenpunkten werden in der Praxis aus der Analyse in den meisten Fällen ausgeschlossen, einfach deswegen, weil das am schnellsten geht. Bevor das gemacht wird, sollte allerdings immer die Frage vorangestellt werden, wieso diese Datenpunkte fehlen. Fehlen sie zufällig, so führt der Ausschluss der Beobachtungen zu keinen unterschiedlichen Ergebnissen. Fehlen sie allerdings systematisch, beispielsweise wenn Personen mit bestimmten Merkmalen spezifische Daten lieber zurückhalten, so ergeben sich daraus Herausforderungen. Es sollte dann darum gehen, diese gesamte Verteilung zu ermitteln. Ist unklar, ob die Daten zufällig oder systematisch fehlen, so sollte sich der Analyst im Zweifel dieser Frage annehmen. Es müssen dann Informationen identifiziert werden, welche helfen die fehlenden Daten zu imputieren.

  1. Ausreißer

Ausreißer werden in vielen Anwendungen mit standardisierten Verfahren identifiziert und aus dem Datensatz entfernt. Dabei lohnt es sich in vielen Fällen, die Daten ernst zu nehmen. Die Voraussetzung hierfür: die Datenpunkte müssen legitim sein. Problemlos ausschließen lassen sich Datenpunkte, welche durch Eingabefehler und bewusste Falschmeldung erzeugt wurden. Legitime Datenpunkte sind hingegen “echte” Werte. Die Einbeziehung von Ausreißern kann mitunter einen inhaltlichen Beitrag zur Analyse leisten, da auch sie einen Teil der Population im Ganzen sind. Problematisch wird die Beibehaltung von Ausreißern, wenn durch sie Zusammenhänge identifizierbar werden, die auf den Rest der Population nicht zutreffen. Mögliche Verfahren, welche Ausreißer mit dem Rest der Beobachtungen versöhnen, sind Transformationen der Daten oder die Anwendung robuster Schätzverfahren. Beide Ansätze spielen mit einer stärkeren Gewichtung der mittleren Verteilung. Außerdem kann beispielsweise in Regressionen überprüft werden, inwieweit etwa ein nicht-linearer Fit die Ausreißer besser in die Schätzung aufnimmt.

  1. Spezifizierung versus Modellierung

Allzu oft werden komplizierte statistische Modelle gebaut, bevor überprüft wurde, was ein einfaches Modell leisten kann. Bevor jedoch komplexe Modelle gestrickt werden, sollte zuerst an der Spezifikation des Modells gearbeitet werden. Kleine Anpassungen wie die Inklusion verbesserter Variablen, die Berücksichtigung von Interaktionen und nicht-linearen Effekten bringen uns in manchen Fällen der Wahrheit näher als ein aufwendiges Modell und sollten in jedem Fall ausgereizt werden, bevor ein aufwendigeres Modell gewählt wird. Je einfacher das Modell, desto einfacher ist es in der Regel auch die Kontrolle darüber zu behalten. In jedem Fall sollten die gewählten Spezifikationen immer durch Sensitivitätsanalysen unterstützt werden. Unterschiede in der Variablendefinition und der Selektion der Daten, sollten sowohl getestet als auch berichtet werden. Einen guten Grund, das Modell zu wechseln hat der Analyst dann, wenn daraus ersichtlich wird, dass Annahmen des einfachen Modells verletzt werden und dieses deswegen keine validen Ergebnisse produziert.

Komplexe Abläufe verständlich dargestellt mit Process Mining

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

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

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 &nbsp; &nbsp; # Verknüpfung ohne Seperator
c = a";"b &nbsp; # 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.

 

Datenvisualisierung in Python [Tutorial]

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()

 

Extraktion von Software-Metriken aus Java-Dateien mit ANTLR4

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.

3D-Visualisierung von Graphen

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

Flexible ABC Analyse mit Excel Power Pivot und DAX

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

Hadoop und Connected Cars

Wie Automotive Unternehmen mehr aus großen Datenmengen machen

Wussten Sie schon: Für 13% der Autokäufer ist ein Neu-Fahrzeug ohne Internetzugang ein “no-go”! Dreizehn Prozent! Das bedeutet gleichzeitig 13% weniger Umsatz für den OEM. Die Unternehmensberatung Bain erwartet, dass diese sogenannten Connected Cars in nur wenigen Jahren die Regel und nicht mehr die Ausnahme sein werden.  

Dabei sind Connected Cars nur der Anfang: OEMs stehen jetzt vor der Herausforderung, ihr Portfolio noch einmal deutlich zu erweitern. Ziel ist es, eine breite Palette maßgeschneiderter Produkte anzubieten, um die immer unterschiedlicheren Erwartungen an Kundennutzen, Fahrerlebnis, Lebenszyklus und Garantie zu erfüllen.

Um all diese Angebote zu identifizieren, zu entwickeln und auch betriebswirtschaftlich tragbar zu machen, müssen Daten analysiert werden – viele Daten!  Read more