IIIb. Einführung in TensorFlow: Realisierung eines Perzeptrons mit TensorFlow

In [1]:
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Reset des TensorFlows
tf.reset_default_graph() 

Daten laden und eigene Definitionen

In [2]:
data = pd.read_csv('data_train.csv')
input_X = data[['x0', 'x1']]
input_y = data.y

data_test = pd.read_csv('data_test.csv')
test_X = data_test[['x0', 'x1']]
test_y = data_test.y

Damit unser Modell schneller lernt, teilen wir unseren Datensatz in Stapel ein. Dafür erstellen wir eine Funktion, welche unseren Datensatz in Stapel teilt!

Je nach Datensatz und Modell empfehlt sich eine andere Stapelgröße.

In [3]:
def stapel_erstellen(X, Y, stapel_grosse, p_index):
    return X[stapel_grosse * p_index: stapel_grosse * (p_index + 1)], Y[stapel_grosse * p_index: stapel_grosse * (p_index + 1)]

Erstellen des Graphen

Formen der Tensoren

In [4]:
# Anzahl der Ergebnissspalten
anz_unit = 1
# Anzahl der Eingänge bzw. Merkmale 
anz_ein = 2
# Anzahl der Ausgänge
anz_aus = 1

Parameter zur Steuerung des Graphen

Die richtige Wahl der Parameter zur Steuerung des Graphen sind entscheidend, wenn es darum geht, wie schnell ein Modell lernt. Wenn wir zum Beispiel anz_stapel=10 statt anz_stapel=5 nutzen, dann brauch unser Modell länger um eine Genauigkeit von 100 % zu erreichen, wenn überhaupt.

In [5]:
# Lernrate
eta = 0.1
# Anzahl der der Pakete mit den zu analysierenden Datenwerte
anz_stapel = 5
# Anzahl der zu analysierenden Datenwerte
stapel_grosse = int(len(input_X)/anz_stapel)
# Anzahl der Wiederholungen
epochen = 50

Relevante Größen

In [6]:
# Eingangssignal
x = tf.placeholder(tf.float32, shape=[None, anz_ein],name='Input')  # Stapelgröße(k) x 2
# Ausgangssignal
y_true = tf.placeholder(tf.float32, shape=None, name='Labels')  # Stapelgröße(k) x 1
# Gewichte
w = tf.Variable(tf.random_normal([anz_ein, anz_unit]), name='Weights')  # 2x1

Berechnungsgleichungen

In der Theorie sind wir immer nur einen Datenpunkt in Betracht gezogen. In TensorFlow wollen wir jedoch einen Stapel betrachten. Dadurch ändert sich die Berechnung ein wenig. Wir berechnen für alle Punkte eine Fehlerfunktion. Der Mittelwert aller Fehlerfunktionen, die Kostenfunktion, soll dann optimiert werden.

In [7]:
# z = xw
z = tf.matmul(x, w, name='Z')
# H = y * -log(sigmoid(z)) + (1 - y) * -log(1 - sigmoid(z)) -> Kreuzentropie
err = tf.reduce_mean(
    tf.nn.sigmoid_cross_entropy_with_logits(labels=y_true, logits=z),name='Costfunction')
# Minimieren der Fehlerfunktion
opt = tf.train.GradientDescentOptimizer(learning_rate=eta).minimize(err)

# Berechnung der Genauigkeit
eins = tf.reshape(tf.round(tf.sigmoid(z)),[len(test_X), 1])
zwei = tf.reshape(y_true,[len(test_X), 1])
acc = tf.equal(eins, zwei)
acc = tf.reduce_mean(tf.cast(acc, tf.float32), name='Accuracy')

Ausführung des Graphen

Bei der Ausführung ist es wichtig, dass wir die Variablen initialisieren. Auch ist es vorteilhaft, wenn wir die Session mit with starten.

In [8]:
# Größen zur späteren Datenvisualisierung
W_set = []
Err_set = []
Acc_set = []
# Initialisierung der Variablen
init = tf.global_variables_initializer()
# Ausführung des Graphen
with tf.Session() as sess:
    # Wichtig für TensorBoard
    writer = tf.summary.FileWriter('./graphs/perceptron', sess.graph)
    sess.run(init)
    # Schleife für Epoche
    for e in range(epochen):
        # Schleife für Stapel
        for i in range(anz_stapel):
            # Einteilen unserer Daten in Stapel
            stapel_x, stapel_y = stapel_erstellen(X=input_X,
                                                  Y=input_y,
                                                  stapel_grosse=stapel_grosse,
                                                  p_index=i)
            # Ausführung der Berechnung
            Z, W, _, Err = sess.run([z, w, opt, err],
                                    feed_dict={x: stapel_x, y_true: stapel_y})

        # Datenspeicherung für Visualisierung über die Epochen
        W_set.append(W)
        Err_set.append(np.mean(Err))
        Acc = sess.run([acc],
                       feed_dict={x: test_X, y_true: test_y})
        Acc_set.append(Acc)
        print('{:}. Epoche Genauigkeit: {:.2f} %'.format(e, Acc[0]*100))
    sess.close()
0. Epoche Genauigkeit: 50.75 %
1. Epoche Genauigkeit: 65.00 %
2. Epoche Genauigkeit: 80.75 %
3. Epoche Genauigkeit: 93.00 %
4. Epoche Genauigkeit: 97.75 %
5. Epoche Genauigkeit: 98.75 %
6. Epoche Genauigkeit: 99.75 %
7. Epoche Genauigkeit: 100.00 %
8. Epoche Genauigkeit: 100.00 %
9. Epoche Genauigkeit: 100.00 %
10. Epoche Genauigkeit: 100.00 %
11. Epoche Genauigkeit: 100.00 %
12. Epoche Genauigkeit: 100.00 %
13. Epoche Genauigkeit: 100.00 %
14. Epoche Genauigkeit: 100.00 %
15. Epoche Genauigkeit: 100.00 %
16. Epoche Genauigkeit: 100.00 %
17. Epoche Genauigkeit: 100.00 %
18. Epoche Genauigkeit: 100.00 %
19. Epoche Genauigkeit: 100.00 %
20. Epoche Genauigkeit: 100.00 %
21. Epoche Genauigkeit: 100.00 %
22. Epoche Genauigkeit: 100.00 %
23. Epoche Genauigkeit: 100.00 %
24. Epoche Genauigkeit: 100.00 %
25. Epoche Genauigkeit: 100.00 %
26. Epoche Genauigkeit: 100.00 %
27. Epoche Genauigkeit: 100.00 %
28. Epoche Genauigkeit: 100.00 %
29. Epoche Genauigkeit: 100.00 %
30. Epoche Genauigkeit: 100.00 %
31. Epoche Genauigkeit: 100.00 %
32. Epoche Genauigkeit: 100.00 %
33. Epoche Genauigkeit: 100.00 %
34. Epoche Genauigkeit: 100.00 %
35. Epoche Genauigkeit: 100.00 %
36. Epoche Genauigkeit: 100.00 %
37. Epoche Genauigkeit: 100.00 %
38. Epoche Genauigkeit: 100.00 %
39. Epoche Genauigkeit: 100.00 %
40. Epoche Genauigkeit: 100.00 %
41. Epoche Genauigkeit: 100.00 %
42. Epoche Genauigkeit: 100.00 %
43. Epoche Genauigkeit: 100.00 %
44. Epoche Genauigkeit: 100.00 %
45. Epoche Genauigkeit: 100.00 %
46. Epoche Genauigkeit: 100.00 %
47. Epoche Genauigkeit: 100.00 %
48. Epoche Genauigkeit: 100.00 %
49. Epoche Genauigkeit: 100.00 %
In [9]:
w_0, w_1 = zip(*W_set)
fig, ax = plt.subplots(3,1, figsize=(15,30), sharex='all')
ax[0].plot(range(len(W_set)), w_0, label='w0')
ax[0].plot(range(len(W_set)), w_1, label='w1')
ax[0].legend()
ax[0].grid()
ax[0].set_title('Gewichte')

ax[1].plot(range(len(W_set)), Err_set, c='r', label='err')
ax[1].legend()
ax[1].set_title('Fehlerfunktion')
ax[1].grid()

ax[2].plot(range(len(W_set)), Acc_set, c='g', label='acc')
ax[2].legend()
ax[2].set_title('Genauigkeit')
ax[2].set_xlabel('Epoche')
ax[2].grid()

Zusammenfassung

Nun haben wir unser Perzeptron erfolgreich mit TensorFlow realisiert. Um ein Gefühl zu bekommen, könnt ihr gerne mit den "Parameter zur Steuerung des Graphen" herumexperimentieren. Je nach Auswahl der Parameter ändert sich die Optimierung und sogar die Genauigkeit unseres Modells. Bei so einfachen Daten, sollte unser Modell definitiv 100% Genauigkeit erreichen. Dies ist jedoch nur möglich, wenn wir die richtigen Parameter wählen. Probiert es also einfach mal aus.

PS: Wenn ihr die Trainings- und Testdaten sucht, dann werdet ihr auf Github fündig.

Künstliche Intelligenz und Vorurteil

Kaum ein anderes technologisches Thema heutzutage wird hinsichtlich gesellschaftlicher Auswirkungen so kontrovers diskutiert wie das der Künstlichen Intelligenz (KI). Während das Wörtchen „KI“ bei den einen Zukunftsvisionen hervorruft, in welchen technologischer Fortschritt menschliche Probleme wie Hunger, Krankheit und Klimawandel reduziert hat, zeichnen andere düstere Bilder von Orwell‘schen Überwachungsstaaten und technologischen Apokalypsen.

Starke, schwache KI

Es ist die Unschärfe des Begriffes „KI“, welcher eine derart große Bandbreite an Zukunftsszenarien ermöglicht. Für diejenigen, welche sich an solch spekulativen Debatten beteiligen, beutet KI „starke KI“ – eine künstliche Intelligenz, deren intellektuellen Fähigkeiten die eines Menschen erreichen oder gar übertreffen. Und so spannend die Diskussion über starke KI auch ist – sie ist reine Spekulation. Heute existierende KI ist weit, sehr weit von starker KI entfernt. Worüber wir heutzutage verfügen ist die sogenannte „schwache KI“ – Algorithmen, die spezifische Anwendungsprobleme (z.B. Bilderkennung, Spracherkennung, Übersetzung, Go spielen) lösen können. Und das mitunter sehr viel besser als Menschen.

Wo heutzutage „KI“ draufsteht, sind innen überwiegend Algorithmen aus dem Bereich des maschinellen Lernens (allen voran Deep Learning) am Werk. Diese Algorithmen können selbständig die Vorgehensweise erlernen, die zum Beispiel nötig ist, um einen gegebenen Input (z.B. ein Bild) auf einen gegebenen Output (z.B. eine Kategorie, welche den Bildinhalt beschreibt) abzubilden. Aber selbst diese „schwache KI“ birgt beträchtliches Potential – denken wir an mögliche Verbesserungen z.B. im Bereich der Medizin, Logistik, Verkehrssicherheit oder Energie- und Ressourcennutzung! Angesichts der Chancen, heutige Prozesse und Anwendungen zu verbessern, haben wir allen Grund, dem Einsatz von KI aufgeschlossen gegenüber zu stehen. Vorausgesetzt natürlich, dass KI verantwortungsvoll, „ethisch“ und sicher eingesetzt wird.

KI auf Abwegen

Ethische Herausforderungen von KI ergeben sich dabei zum einen durch die Zielsetzung. Wie ein Hammer für den Nagel an der Wand oder für den Hinterkopf eines Gegners verwendet werden kann, kann auch KI für böse Ziele missbraucht werden. Nur, dass KI im Zweifel deutlich größeren Schaden anrichten kann als ein einfacher Hammer. Und so sollten wir angesichts der Risiken dringend international diskutieren, wie wir uns hinsichtlich militärischer Anwendungen von KI verhalten wollen.

Zum anderen dringen besonders aus den USA, in denen KI Algorithmen schon heute in deutlich größerem Ausmaß eingesetzt werden als in Deutschland, immer wieder beunruhigende Nachrichten über voreingenommene KI Algorithmen. Zum ersten fand eine Studie kürzlich heraus, dass kommerziell erhältliche Gesichtserkennungsalgorithmen für Frauen bzw. dunkelhäutige Menschen schlechter funktionieren als für Männer bzw. hellhäutige Menschen. Mit der unschönen Konsequenz, dass es z.B. bei einem Abgleich mit Verbrecherfotos bei Menschen mit dunkler Hautfarbe deutlich häufiger zu falschen Übereinstimmungen kommen kann als bei Menschen heller Hautfarbe. Zum zweiten wurde vor kurzem bekannt, dass eine experimentell von einem großen Technologiekonzern zur Bewertung von Bewerbungen verwendete KI von Frauen stammende Bewerbungen systematisch schlechter bewertete als von Männern stammende Bewerbungen.

Wie KI zu Vorurteilen kommt

Um die Ursachen für vorurteilsbehaftete KI besser zu verstehen, lohnt es sich, einen Blick hinter die Kulissen zu werfen. Denn wie jede Technologie existiert auch KI nicht im luftleeren Raum. Dies lässt sich leicht anhand der Faktoren verdeutlichen, welche zum Erfolg heutiger KI beigetragen haben: bessere Hardware, cleverere Algorithmen und größere Datenmengen. Und gerade diese Daten sind es, durch welche Vorurteile in KI Einzug halten können.

Die Vorstellung von „neutralen Daten“ ist nämlich eine Wunschvorstellung. Im besten Fall spiegeln Daten die Welt wider, in der wir leben.       Eine Welt zum Beispiel, in der in Technologiekonzernen typischerweise deutlich mehr Männer beschäftigt sind als Frauen – was eine auf dem Personalbestand eines Technologiekonzerns trainierte KI dazu veranlassen kann, zu „schlussfolgern“, dass männliche Bewerber im Auswahlverfahren zu bevorzugen sind. Oder eine Welt, in der Länder bzw. gesellschaftliche Schichten innerhalb eines Landes unterschiedlichen Zugang zu modernen Technologien oder auch Bildung haben. Eine Ungleichheit, die sich als Dominanz westlicher Industrienationen in der geografischen Zusammensetzung von zum Training von KI-Algorithmen verwendeter Datensätze auswirken kann. Eine Dominanz, die wiederum zur Folge haben kann, dass derart trainierte KI-Algorithmen besonders gut für Menschen aus westlichen Industrienationen funktionieren. Ganz zu schweigen von der Voreingenommenheit der menschlichen Wahrnehmung, welche die Zusammensetzung von Daten beeinflusst – denken wir an das begrenzte Spektrum der Bilder, welche uns zuerst zu dem Begriff „Genie“ in den Sinn kommen.

Aber nicht nur die verwendeten Trainingsdaten, sondern auch bei der Entwicklung von KI getroffenen Design-Entscheidungen können negative Auswirkungen haben. Wenn bei einem nicht perfekt funktionierenden Bilderkennungsalgorithmus potentiell abwertende Kategorien zur Klassifikation zur Verfügung stehen, kann dies dazu führen, dass – wie in der Vergangenheit geschehen – dunkelhäutige Menschen als Gorillas klassifiziert werden. Wenn bei der Evaluation eines z.B. für die Gesichtserkennung eingesetzten KI-Algorithmus nur die Genauigkeit über alle Bevölkerungsgruppen hinweg berücksichtigt wird, können Ungleichheiten in der Genauigkeit nicht entdeckt werden, was zu Problemen bei der Anwendung führen kann. Denn Nutzer von KI-Algorithmen vermuten zumeist, dass die Algorithmen für alle denkbaren Anwendungszwecke geeignet sind.

Werte statt Wegsehen

Entgegen der verbreiteten Auffassung sind KI Algorithmen also nicht notwendigerweise vorurteilsfrei – sie können menschliche Voreingenommenheit bzw. gesellschaftliche Ungleichheit widerspiegeln. Da Algorithmen anders und in anderem Maß als Menschen eingesetzt werden, kann das bei blauäugiger Verwendung dazu führen, dass bestehende Ungleichheiten nicht nur bestärkt, sondern sogar vergrößert werden. Richtig angewendet können Algorithmen jedoch helfen, implizite und explizite Vorurteile menschlicher Entscheider zu mindern. Denn wie wir durch viele Studien wissen, ist die Liste der kognitiven Verzerrungen, die wir Menschen aufweisen, lang.

Es ist für den verantwortlichen Einsatz von KI in einem sensiblen Kontext somit essenziell, zu wissen, welche „ethischen“ Kriterien KI für den konkreten Anwendungsfall erfüllen muss. So kann sichergestellt werden, dass die KI den Anforderungen entspricht, bevor sie angewendet wird – oder aber, dass sie solange nicht angewendet wird, wie sie den Anforderungen nicht entspricht. Und mittels Transparenz, Überwachung und Feedback-Möglichkeiten lässt sich vermeiden, dass ein selbst-verbessernder KI-Algorithmus im Laufe der Zeit das ihm gesteckte Ziel verfehlt.

Für viele Anwendungsfälle sind derartige ethische Fragen jedoch vernachlässigbar, denken wir zum Beispiel an die Vorhersage von Maschinenausfällen oder die Extraktion strukturierter Daten aus unstrukturierten Dokumenten. Aber es ist nichtsdestotrotz gut und wichtig, Ethik und KI zusammen zu denken. Denn dies ermöglicht es uns, sicherzustellen, dass wir KI auf die bestmögliche Weise einsetzen. Denn das enorme Potential von KI gibt uns die Chance, den Status quo nachhaltig positiv zu verändern – technologisch wie ethisch.

IIIa. Einführung in TensorFlow: Realisierung eines Perzeptrons mit TensorFlow

1. Einleitung

1.1. Was haben wir vor?

Im zweiten Artikel dieser Serie sind wir darauf eingegangen, wie man TensorFlow prinzipiell nutzt. Wir wollen das Gelernte an einem einfachen Modell anwenden. Bevor wir dies jedoch tun, müssen wir die Theorie hinter dem Modell verstehen um TensorFlow richtig anwenden zu können.

Dafür bietet sich ein Adaline-Perzeptron sehr gut an. Es ist ein einfaches Modell mit nur einer Schicht, wo die Theorie verständlich ist.

1.2. Aufgabenstellung

Abb.1 Trainingsdaten: Grün \rightarrow Label 0, Rot
\rightarrow Label 1

In Abb.1 sehen wir unsere Trainingsdaten, die
zufällig generiert wurden. Alle grün markierten Datenpunkte haben das Label 0 und die rot markierten Punkte erhalten das Label 1. 

Wir möchten einen Adaline-Perzeptron entwickeln, der unsere Daten  je nach Position in die richtige Klasse zuordnet. Somit haben wir eine Aufgabe mit binärer Klassifikation

2. Grundlagen

2.1. Funktionsweise eines Perzeptrons

Ein Perzeptron ist ein mathematisches Modell, welches eine Nervenzelle beschreiben soll.

Abb.2 Schematische Darstellung einer Nervenzelle und ihren Bestandteilen

Vereinfacht funktioniert eine Nervenzelle, auch Neuron genannt, folgendermaßen: Eine Vielzahl von Reizen bzw. Eingabesignalen wird von den Dendriten aufgenommen, die dann im Kern verarbeitet werden. Wenn die verschiedenen Eingabesignale die ’richtige’ Dosis an Reizen erreichen und einen Schwellwert erreichen, dann feuert das Neuron ab und leitet ein Signal weiter. 

Für eine detaillierte Beschreibung, wie ein Perzeptron mathematisch beschrieben wird, möchte ich auf diesen Artikel hinweisen.

Wir wollen uns in diesem Artikel auf den Adaline-Algorithmus (ADAptive LINear Element) konzentrieren. Dieser ist eine Weiterentwicklung des Perzeptron. Die Besonderheit an diesem Algorithmus liegt darin, dass das Konzept der Fehlerminimierung durch Minimierung der Straffunktion der berechneten und der tatsächlichen Ergebnisse enthält. Ein weiter wesentlicher Unterschied zu einem einfachen Perzeptron ist vor allem, dass wir bei Adaline keine einfache Sprungfunktion als Aktivierungsfunktion haben, sondern eine stetige Funktion nutzen und somit eine Differenzierung/Ableitung der Aktivierungsfunktion durchführen können. Dieser Punkt ist für die Optimierung der Gewichte und des Lernens unseres Modells ein entscheidender Vorteil.

Das Schema in Abb.3 zeigt uns die Funktionsweise, wie unser Adaline-Algorithmus funktionieren soll.

Abb.3 Schematische Darstellung des Adaline-Perzeptrons

  1. Eingang: In dieser Schicht werden unsere Daten ein gepfangen und weitergeleitet
  2. Die Gewichte geben an, welchen Einfluss unsere Eingangssignale haben. Sie sind auch unsere Größe, die in unserem Algorithmus optimiert werden.
  3. Die Nettoeingabefunktion wird durch die Zusammenführung von Eingangssignalen und Gewichten erzeugt. Je nachdem wie die Eingänge und Gewichte verbunden sind,  müssen diese mathematisch korrekt multipliziert werden.
  4. Die Nettoeingabe wird dann, in die Aktivierungsfunktion eingebunden. Je nachdem welche Aktivierungsfunktion man nutzt, ändert sich die Ausgabe nach der Aktivierungsfunktion. 
  5.  In der Fehlerrückgabe werden die vorhergesagten Ausgaben mit den tatsächlichen Werten/Labels verglichen. Auch hier gibt es verschiedene Verfahren, um eine Fehlerfunktion zu bilden. 
  6. In der Optimierung werden dann auf Basis der Fehlerfunktion die Gewichte so optimiert, dass der Fehler zwischen unseren Label und den vorhergesagten Werten minimiert wird.
  7. Der Quantisierer ist ein optionales Element. Bei einer kategorischen Problemstellung bekommen wir nach der Aktivierungsfunktion eine Wahrscheinlichkeit zu der die Daten zu welchem Label zugeteilt werden. Der Quantisierer wandelt diese Wahrscheinlichkeiten zu Labeln um. Zum Beispiel haben wir einen Datensatz und unser Modell sagt voraus, dass dieser Datensatz zu 88 % das Label 1 hat. Je nachdem welche Grenze dem Quantisierer gegeben wird, teilt dieser dann den Datensatz in die entsprechende Klasse ein. Wenn wir sagen die Grenze soll 50% sein, dann sagt der Quantisierer, dass unser Datensatz Label 1 ist.

2.2. Aktivierungsfunktionen

Die Aktivierungsfunktion ist ein sehr wichtiger Bestandteil bei neuronalen Netzen. Diese bestimmen, wie sich das Ausgangssignal verhält. Es gibt eine Vielzahl von Aktivierungsfunktionen, die ihre Vor- und Nachteile haben. Wir wollen uns erstmal auf die Sigmoidfunktion konzentrieren.

Eigentlich haben wir bei der Sprungfunktion alles was wir brauchen. Wenn wir einen Schwellenwert erreichen z \geq 0, dann feuert die Sprungfunktion und das sehr abrupt. Die Sigmoidfunktion hingegen hat einen sanfteren und natürlicheren Verlauf als die Sprungfunktion. Außerdem ist sie eine stetig und differenzierbare Funktion, was sehr vorteilhaft für das Gradientenverfahren (Optimierung) ist. Daher wollen wir die Sigmoidfunktion für unsere Problemstellung nutzen.

    \begin{align*} \text{sig}(z) = \frac{1}{1 + e^{-z}}\end{align*}

Abb.4 Sigmoid-Funktion mit ihrer Ableitung und deren Sättigungsbereichen

2.3. Optimierungsverfahren

2.3.1. Fehlerfunktion

Die wohl am häufigsten genutzten Fehlerfunktionen (oder auch Ziel-, Kosten-, Verlust-, Straffunktion) sind wohl der mittlere quadratische Fehler bei Regressionen und die Kreuzentropie bei kategorischen Daten.

In unserem Beispiel haben wir Daten kategorischer Natur und eine binäre Thematik, weshalb wir uns auf die Kreuzentropie in Kombination mit der Sigmoidfunktion konzentrieren wollen.

Aus der Matrizenrechnung t (z =\boldsymbol{xw}^T) erhalten wir ein Skalar (eindimensional). Geben wir diese in die Sigmoidfunktion ein, kommen wir auf folgende Gleichung.



    \begin{align*} \text{sig}(z=\boldsymbol{xw}^T) = \frac{1}{1 + e^{-\boldsymbol{xw}^T}} \end{align*}


Hinweis: Wie in Abb.4 kann die Sigmoidfunktion nur Werte zwischen 0 und 1 erreichen, ohne diese jemals zu erreichen. Außerdem ändert sich die Funktion bei sehr großen Beträgen nur noch minimal, man spricht auch von Sättigung. Dieser Fakt ist sehr wichtig, wenn um die Optimierung der Gewichte geht. Wenn wir unsere Nettoeingabe nicht skalieren, dann kann es passieren, dass unser Modell sehr langsam lernt, da der Gradient der Sigmoidfunktion bei großen Beträgen sehr klein ist.

Bei Aufgaben mit binärer Klassifizierung hat sich die Kreuzentropie als Fehlerfunktion etabliert. Sie ist ein Maß für die Qualität eines Modells, welche eine Wahrscheinlichkeitsverteilung angibt. Je kleiner diese Größe ist, desto besser unser Modell. Es gilt also unsere Fehlerfunktion zu minimieren!

Wir wollen in einem separaten Artikel genauer auf die Kreuzentropie eingehen. Für den jetzigen Zeitpunkt soll es reichen, wenn wir die Formel vor Augen haben und was sie grob bedeutet.

P = \{p_1,p_2,\dots,p_N\} sei die ‘wahre’ Wahrscheinlichkeitsverteilung aus der Menge X = \{x_1,x_2,\dots,x_N\}, in unserem Fall, die Wahrscheinlichkeitsverteilung, ob ein Datenpunkt dem Label 0 oder 1 zugehört. Wenn wir nun unser Eingangssignal durch die Aktivierungsfunktion fließen lassen, dann erhalten wir ebenfalls eine ‘berechnete’ Wahrscheinlichkeitsverteilung die Q = \{q_1,q_2,\dots,q_N\} genannt werden soll. Um die Wahrscheinlichkeitsverteilungen p und q zu vergleichen, nutzen wir die Kreuzentropie, welche wie folgt für diskrete Daten definiert ist:

    \begin{align*}\log_2{x}&= \operatorname{ld}(x) \\H(P;Q) &= - \sum{P \cdot \operatorname{ld}(Q)}\\H(P;Q) &= -p_1 \operatorname{ld}(q_1) - p_2  \operatorname{ld}(q_2)\end{align*}

Beispiel einer binären Problemstellung. Wir haben unsere Label 0 und 1. p1 ist die Wahrscheinlichkeit, inwiefern unser Datenpunkt das Label 0 hat. Da wir die Trainingsdaten kennen, wissen wir auch das dieser Punkt zu 100 %, welches Label hat. Unser Modell hat zum Beispiel im ersten Durchgang eine Wahrscheinlichkeit von 0.8 und später 0.9 berechnet.

Fall I : P = Q Die Wahrscheinlichkeitsverteilungen P und Q sind identisch:

    \begin{align*}P &= \{p_1 = 1.0, p_2 = 0.0 \} \\Q_0 &= \{q_1 = 1.0, q_2 = 0.0 \} \\ \\H_{0}(P;Q_I) &= -1.0 \operatorname{ld}(1) -0.0 \operatorname{ld}(0.0) = 0.0\\\end{align*}

Fall II: P \neq Q Die Wahrscheinlichkeitsverteilungen P und Q sind nicht identisch:

    \begin{align*}P &= \{p_1 = 1.0, p_2 = 0.0 \} \\Q_{1} &= \{q_1 = 0.8, q_2 = 0.2 \} \\ Q_{2} &= \{q_1 = 0.9, q_2 = 0.1 \} \\ Q_{3} &= \{q_1 = 0.99, q_2 = 0.01 \} \\ \\H_{1}(P;Q_{1}) &= -1.0 \operatorname{ld}(0.8) -0.0 \operatorname{ld}(0.2) = 0.3219 \\H_{2}(P;Q_{2}) &= -1.0 \operatorname{ld}(0.9) -0.0 \operatorname{ld}(0.1) = 0.1520 \\ H_{3}(P;Q_{3}) &= -1.0 \operatorname{ld}(0.99) -0.0 \operatorname{ld}(0.01) = 0.0144\\\end{align*}

In der oberen Berechnung haben wir zum einfachen Verständnis der Kreuzentropie ein einfaches Beispiel. p_1 ist eine 100 % ige  Wahrscheinlichkeit, dass zum Beispiel unser Datensatz das Label 0 hat. Unser perfektes Modell mit Q_0 hat eine Kreuzentropie-Wert von 0. Unser zweites Modell  H_1(P;Q1) hat eine gewisse Unbestimmtheit, die sich durch eine größere Kreuzentropie H_1 = 0.1520 bemerkbar macht. Je mehr sich also unser Modell von den wirklichen Daten abweicht, desto größer ist die Kreuzentropie.

2.3.2. Optimierung nach dem Gradientenverfahren

Wenn wir es also schaffen die Kreuzentropie zu minimieren, dann erhalten wir auch ein besseres Modell! Bei der Optimierung nach dem Gradientenverfahren versuchen wir uns schrittweise an das Minimum zu bewegen.

    \begin{align*}H(P;Q) &= H(y; \varPhi(z)) \\            &= H(y; \text{sig}(z))\\             &= H(y; \text{sig}(xw))\\H' &= \frac{\partial H}{\partial w} \rightarrow Min.\end{align*}

Ziel der Optimierung ist es, dass unsere Gewichte so angepasst werden, dass sich der Fehler in unserer Fehlerfunktion minimiert. Wir leiten also die Fehlerfunktion nach w ab. 

Diese Aufgabe wird zum Glück von TensorFlow übernommen und wir müssen die Randbedingungen nur dem System geben.

Neben dem Gradientenverfahren, gibt es auch noch eine Menge anderer Optimierer, auf die wir später nochmal eingehen werden.

3. Zusammenfassung

Bevor wir TensorFlow nutzen, ist es wichtig, dass wir unser Modell verstehen. TensorFlow ist wie vieles nur ein Werkzeug, wenn man die Grundlagen nicht verstanden hat. Daher haben wir uns in diesem Artikel erstmal auf die Theorie konzentriert und ich habe dabei versucht mich auf das Wesentliche zu beschränken. 

Im nächsten Artikel werden wir dann unser Modell in TensorFlow realisieren.

PS: In einem separaten Artikel wollen später nochmal detaillierter auf Aktivierungsfunktion, Kreuzentropie und das Gradientenverfahren eingehen.

Data Leader Days 2018 – Review

Das Who’s Who der Datenwirtschaft auf den Data Leader Days 2018

Berlin, Dezember 2018: Die Data Leader Days am 14./15. November 2018 im Berliner Spreespeicher haben erneut die Entscheider aus der Business- und Digitalwelt versammelt und wichtige Impulse ausgesendet. Die in diesem Jahr zum dritten Mal stattfindende Veranstaltung verzeichnete mit knapp 300 Teilnehmern einen enormen Besucherzuwachs. Organisiert wurde die Konferenz von DATANOMIQ und dem Connected Industry.

Der Auftakttag stand ganz unter dem Zeichen von Commercial und Finance Data: Besondere Highlights waren hier die Vorträge von Dr. Joachim Schmalzl, Vorstandsmitglied des Dt. Sparkassen- und Giroverbands, der auf die Fortschritte der Sparkassen bei der Umsetzung von digitalen Innovationen einging sowie Marcus Hartmann, Chief Data Officer der ProSieben Sat. 1 Media mit seiner Keynote. Im Fokus des zweiten Tages standen Industrial und Automotive Data. Hier konnten Digitalmanager von BASF, Heidelberger Druckmaschinen, E.ON, Wittenstein, Vodafone, Schaeffler und Airbus anhand von Live Demos und Use Cases die Themen Data Science & Machine Learning, Data Engineering sowie Data Visualization vorstellen.

Die Data Leader Days freuen sich auch im nächsten Jahr wieder auf eine große Resonanz. Das Event findet wieder in Berlin am 13./14. November 2019 statt.

Data Leader Days Sponsors and Audience

Predictive maintenance in Semiconductor Industry: Part 1

The process in the semiconductor industry is highly complicated and is normally under consistent observation via the monitoring of the signals coming from several sensors. Thus, it is important for the organization to detect the fault in the sensor as quickly as possible. There are existing traditional statistical based techniques however modern semiconductor industries have the ability to produce more data which is beyond the capability of the traditional process.

For this article, we will be using SECOM dataset which is available here.  A lot of work has already done on this dataset by different authors and there are also some articles available online. In this article, we will focus on problem definition, data understanding, and data cleaning.

This article is only the first of three parts, in this article we will discuss the business problem in hand and clean the dataset. In second part we will do feature engineering and in the last article we will build some models and evaluate them.

Problem definition

This data which is collected by these sensors not only contains relevant information but also a lot of noise. The dataset contains readings from 590. Among the 1567 examples, there are only 104 fail cases which means that out target variable is imbalanced. We will look at the distribution of the dataset when we look at the python code.

NOTE: For a detailed description regarding this cases study I highly recommend to read the following research papers:

  •  Kerdprasop, K., & Kerdprasop, N. A Data Mining Approach to Automate Fault Detection Model Development in the Semiconductor Manufacturing Process.
  • Munirathinam, S., & Ramadoss, B. Predictive Models for Equipment Fault Detection in the Semiconductor Manufacturing Process.

Data Understanding and Preparation

Let’s start exploring the dataset now. The first step as always is to import the required libraries.

There are several ways to import the dataset, you can always download and then import from your working directory. However, I will directly import using the link. There are two datasets: one contains the readings from the sensors and the other one contains our target variable and a timestamp.

The first step before doing the analysis would be to merge the dataset and we will us pandas library to merge the datasets in just one line of code.

Now let’s check out the distribution of the target variable

Figure 1: Distribution of Target Variable

From Figure 1 it can be observed that the target variable is imbalanced and it is highly recommended to deal with this problem before the model building phase to avoid bias model. Xgboost is one of the models which can deal with imbalance classes but one needs to spend a lot of time to tune the hyper-parameters to achieve the best from the model.

The dataset in hand contains a lot of null values and the next step would be to analyse these null values and remove the columns having null values more than a certain percentage. This percentage is calculated based on 95th quantile of null values.

Figure 2: Missing percentge in each column

Now we calculate the 95th percentile of the null values.

Figure 3: Missing percentage after removing columns with more then 45% Na

From figure 3 its visible that there are still missing values in the dataset and can be dealt by using many imputation methods. The most common method is to impute these values by mean, median or mode. There also exist few sophisticated techniques like K-nearest neighbour and interpolation.  We will be applying interpolation technique to our dataset. 

To prepare our dataset for analysis we should remove some more unwanted columns like columns with near zero variance. For this we can calulate number of unique values in each column and if there is only one unique value we can delete the column as it holds no information.

We have applied few data cleaning techniques and reduced the features from 590 to 444. However, In the next article we will apply some feature engineering techniques and adress problems like the curse of dimensionality and will also try to balance the target variable.

Bleiben Sie dran!!

Location at Data Hacker Days announced

We are happy to announce your our venue for the Data Hacker Days: Kühlhaus Berlin.

Data Hacker Days will take place from 28th to 30st May 2019 in Berlin.

The industrial look of Kühlhaus Berlin is a perfect place to challenge hackers to work and solve the hackathon. The backyard will be a chill area and to take a break or networking with other people.  

More information about Data Hacker you can find on the website: https://datahackerdays.com/

Like our facebook website: https://www.facebook.com/Data-Hacker-Days-278017336397423/

Fuzzy Matching mit dem Jaro-Winkler-Score zur Auswertung von Markenbekanntheit und Werbeerinnerung

Für Unternehmen sind Markenbekanntheit und Werbeerinnerung wichtige Zielgrößen, denn anhand dieser lässt sich ableiten, ob Konsumenten ein Produkt einer Marke kaufen werden oder nicht. Zielgrößen wie diese werden von Marktforschungsinstituten über Befragungen ermittelt. Dafür wird in regelmäßigen Zeitabständen eine gleichbleibende Anzahl an Personen befragt, ob diese sich an Marken einer bestimmten Branche erinnern oder sich an Werbung erinnern. Die Personen füllen dafür in der Regel einen Onlinefragebogen aus.

Die Ergebnisse der Befragung liegen in einer Datenmatrix (siehe Tabelle) vor und müssen zur Auswertung zunächst bearbeitet werden.

Laufende Nummer Marke 1 Marke 2 Marke 3 Marke 4
1 ING-Diba Citigroup Sparkasse
2 Sparkasse Consorsbank
3 Commerbank Deutsche Bank Sparkasse ING-DiBa
4 Sparkasse Targobank

Ziel ist es aus diesen Daten folgende 0/1 codierte Matrix zu generieren. Wenn eine Marke bekannt ist, wird in die zur Marke gehörende Spalte eine Eins eingetragen, ansonsten eine Null.

Alle Marken ING-Diba Citigroup Sparkasse Targobank
ING-Diba, Citigroup, Sparkasse 1 1 1 0
Sparkasse, Consorsbank 0 0 1 0
Commerzbank, Deutsche Bank, Sparkasse, ING-Diba 1 0 0 0
Sparkasse, Targobank 0 0 1 1

Der Workflow um diese Datentransformation durchzuführen ist oftmals mittels eines Teilstrings einer Marke zu suchen ob diese in einem über alle Nennungen hinweg zusammengeführten String vorkommt oder nicht (z.B. „argo“ bei Targobank). Das Problem dieser Herangehensweise ist, dass viele falsch geschriebenen Wörter so nicht erfasst werden und die Erfahrung zeigt, dass falsch geschriebene Marken in vielfältigster Weise auftreten. Hier mussten in der Vergangenheit Mitarbeiter sich in stundenlangem Kampf durch die Ergebnisse wühlen und falsch zugeordnete oder nicht zugeordnete Marken händisch korrigieren und alle Variationen der Wörter notieren, um für die nächste Befragung das Suchpattern zu optimieren.

Eine Alternative diesen aufwändigen Workflow stellt die Ermittlung von falsch geschriebenen Wörtern mittels des Jaro-Winkler-Scores dar. Dafür muss zunächst die Jaro-Winkler-Distanz zwischen zwei Strings berechnet werden. Diese berechnet sich wie folgt:

d_j = \frac{1}{3}(\frac{m}{|s_1|}+\frac{m}{|s_2|}+\frac{m - t}{m})

  • m: Anzahl der übereinstimmenden Buchstaben
  • s: Länge des Strings
  • t: Hälfte der Anzahl der Umstellungen der Buchstaben die nötig sind, damit Strings identisch sind. („Ta“ und „gobank“ befinden sich bereits in der korrekten Reihenfolge, somit gilt: t = 0)

Aus dem Ergebnis lässt sich der Jaro-Winkler Score berechnen:
d_w = \d_j + (l_p (1 - d_j))
ist dabei die Jaro-Winkler-Distanz, l die Länge der übereinstimmenden Buchstaben von Beginn des Wortes bis zum maximal vierten Buchstaben und p ein konstanter Faktor von 0,1.

Für die Strings „Targobank“ und „Tangobank“ ergibt sich die Jaro-Winkler-Distanz:

d_j = \frac{1}{3}(\frac{8}{9}+\frac{8}{9}+\frac{8 - 0}{9})

Daraus wird im nächsten Schritt der Jaro-Winkler Score berechnet:

d_w = 0,9259 + (2 \cdot 0,1 (1 - 0,9259)) = 0,9407407

Bisherige Erfahrungen haben gezeigt, dass sich Scores ab 0,8 bzw. 0,9 am besten zur Suche von ähnlichen Wörtern eignen. Ein Schwellenwert darunter findet sehr viele Wörter, die sich z.B. auch anderen Wörtern zuordnen lassen. Ein Schwellenwert über 0,9 identifiziert falsch geschriebene Wörter oftmals nicht mehr.

Nach diesem theoretischen Exkurs möchte ich nun zeigen, wie sich das Ganze praktisch anwenden lässt. Da sich das Ganze um ein fiktives Beispiel handelt, werden zur Demonstration der Praxistauglichkeit Fakedaten mit folgendem Code erzeugt. Dabei wird angenommen, dass Personen unterschiedlich viele Banken kennen und diese mit einer bestimmten Wahrscheinlichkeit falsch schreiben.

Ausführen:

Nun werden die Inhalte der Spalten in eine einzige Spalte zusammengefasst und jede Marke per Komma getrennt.

Damit Sonderzeichen, Leerzeichen oder Groß- und Kleinschreibung keine Rolle spielen, werden alle Strings vereinheitlicht und störende Zeichen entfernt.

Im nächsten Schritt wird geprüft welche Schreibweisen überhaupt existieren. Dafür eignet sich eine Word-Frequency-Matrix, mit der alle einzigartigen Wörter und deren Häufigkeiten in einem Vektor gezählt wird.

Danach wird eine leere Liste erstellt, in der iterativ für jedes Element des Suchvektors ein Charactervektor erzeugt wird, der Wörter enthält, die einen Jaro-Winker Score von 0,9 oder höher besitzen.

Jetzt wird ein leerer DataFrame erzeugt, der die Zeilenlänge des originalen DataFrames besitzt sowie die Anzahl der Marken als Spaltenlänge.

Im nächsten Schritt wird nun aus den ähnlichen Wörtern mit einer oder-Verknüpfung einen String erzeugt, der alle durch den Jaro-Winkler-Score identifizierten Wörter beinhaltet. Wenn ein Treffer gefunden wird, wird in der Suchspalte eine Eins eingetragen, ansonsten eine Null.

Zuletzt wird eine Spalte erzeugt, in die eine Eins geschrieben wird, wenn keine der Marken gefunden wurde.

Nach der fertigen Berechnung der Matrix können nun die finalen KPI´s berechnet und als Report in eine .xlsx Datei geschrieben werden.

Dieses Vorgehen kann natürlich nicht verhindern, dass sich jemand mit kritischem Auge die Daten anschauen muss. In mehreren Tests ergaben sich bei einer Fallzahl von ~10.000 Antworten Genauigkeiten zwischen 95% und 100%, was bisherige Ansätze um ein Vielfaches übertrifft.9407407

Cloudera beschleunigt die KI-Industrialisierung mit Cloud nativer Machine-Learning-Plattform

Neues Cloudera-Angebot vereinfacht Machine-Learning-Workflows mit einer einheitlichen Erfahrung für Data Engineering und Data Science auf Kubernetes.

München, Palo Alto (Kalifornien), 5. Dezember 2018 – Cloudera, Inc. (NYSE: CLDR) hat eine Vorschau auf eine neue, Cloud-basierte Machine-Learning-Plattform der nächsten Generation auf Basis von Kubernetes veröffentlicht. Das kommende Cloudera Machine Learning erweitert das Angebot von Cloudera für Self-Service Data Science im Unternehmen. Es bietet eine schnelle Bereitstellung und automatische Skalierung sowie eine containerisierte, verteilte Verarbeitung auf heterogenen Rechnern. Cloudera Machine Learning gewährleistet auch einen sicheren Datenzugriff mit einem einheitlichen Erlebnis in lokalen, Public-Cloud- und hybriden Umgebungen.

Im Gegensatz zu Data-Science-Tools, die nur Teile des Machine-Learning-Workflows adressieren oder nur für die Public Cloud verfügbar sind, kombiniert Cloudera Machine Learning Data Engineering und Data Science, auf beliebigen Daten und überall. Darüber hinaus werden Datensilos aufgelöst, um den kompletten Machine-Learning-Workflow zu vereinfachen und zu beschleunigen. Unternehmen können ab sofort hier Zugang zu einer Vorabversion von Cloudera Machine Learning anfragen.

Container und das Kubernetes-Ökosystem ermöglichen die Agilität der Cloud in verschiedenen Umgebungen mit einer konsistenten Erfahrung und ermöglichen die Bereitstellung skalierbarer Services für die IT in hybriden und Multi-Cloud-Implementierungen. Gleichzeitig sind Unternehmen bestrebt, komplette Machine-Learning-Workflows zu operationalisieren und zu skalieren. Mit Cloudera Machine Learning können Unternehmen Machine Learning von der Forschung bis zur Produktion beschleunigen. Benutzer sind in der Lage, Umgebungen einfach bereitzustellen und Ressourcen zu skalieren und müssen so weniger Zeit für die Infrastruktur und können mehr Zeit für Innovationen aufwenden.

Zu den Fähigkeiten gehören:

  • Nahtlose Portierbarkeit über Private Cloud, Public Cloud und Hybrid Cloud auf Basis von Kubernetes.

  • Schnelle Cloud-Bereitstellung und automatische Skalierung.

  • Skalierbares Data Engineering und Machine Learning mit nahtloser Abhängigkeitsverwaltung durch containerisiertes Python, R und Spark-on-Kubernetes.

  • Hochgeschwindigkeits-Deep-Learning mit verteiltem GPU-Scheduling und Training.

  • Sicherer Datenzugriff über HDFS, Cloud Object Stores und externe Datenbanken hinweg.

„Teams produktiver zu machen, ist entscheidend für die Skalierung von Machine Learning im Unternehmen. Modelle konsistent über eine hochskalierbare, transparente Infrastruktur zu erstellen und einzusetzen und dabei überall auf Daten zuzugreifen, erfordert aber eine neuartige Plattform”, sagt Hilary Mason, General Manager, Machine Learning bei Cloudera. „Cloudera Machine Learning vereint die kritischen Funktionen von Data Engineering, kollaborativer Exploration, Modelltraining und -bereitstellung in einer Cloud-basierten Plattform, die dort läuft, wo Sie sie benötigen – mit den integrierten Sicherheits-, Governance- und Managementfunktionen, die unsere Kunden nachfragen.”

„Bei Akamai haben wir ausgereifte Web-Sicherheitssysteme auf der Grundlage einer umfassenden Datenanalyse und -verarbeitung aufgebaut. Dabei ist uns bewusst geworden, dass Geschwindigkeit und Skalierbarkeit entscheidend für die Erkennung von Anomalien im Internet sind”, sagt Oren Marmor, DevOps Manager, Web Security bei Akamai. „Die Agilität, die Docker und Kubernetes Apache Spark verleihen, ist für uns ein wichtiger Baustein, sowohl für Data Science als auch für Data Engineering. Wir freuen uns sehr über die Einführung der kommenden Cloudera Machine Learning Plattform. Die Möglichkeit, mit der Plattform das Abhängigkeitsmanagement von Betriebssystemen und Bibliotheken zu vereinfachen, ist eine vielversprechende Entwicklung.”


Matt Brandwein, Senior Director of Products bei Cloudera, erläutert im Video, wie die neue Cloudera Plattform Teams in die Lage versetzt, Machine Learning im Unternehmen zu entwickeln und einzusetzen.

Mit Cloudera Machine Learning sowie der Forschung und fachkundigen Beratung durch die Cloudera Fast Forward Labs bietet Cloudera einen umfassenden Ansatz zur Beschleunigung der Industrialisierung von KI.

Um Kunden dabei zu unterstützen, KI überall zu nutzen, hat das Applied Research Team von Cloudera kürzlich Federated Learning eingeführt, um Machine-Learning-Modelle von der Cloud bis zum Edge einzusetzen, gleichzeitig den Datenschutz zu gewährleisten und den Aufwand für die Netzwerkkommunikation zu reduzieren. Der Bericht bietet eine detaillierte, technische Erläuterung des Ansatzes sowie praktische technische Empfehlungen, die sich mit Anwendungsfällen in den Bereichen Mobilfunk, Gesundheitswesen und Fertigung befassen, einschließlich IoT-gesteuerter Predictive Maintenance.

„Federated Learning beseitigt Hindernisse für die Anwendung von Machine Learning in stark regulierten und wettbewerbsorientierten Branchen. Wir freuen uns sehr, unseren Kunden helfen zu können, damit Starthilfe für die Industrialisierung der KI zu erhalten”, so Mike Lee Williams, Forschungsingenieur bei Cloudera Fast Forward Labs.


Mike Lee Williams, Research Engineer bei den Cloudera Fast Forward Labs, erklärt im Video, wie Machine-Learning-Systeme mit Hilfe von Federated Learning ohne direkten Zugriff auf Trainingsdaten aufgebaut werden können. 

Über Cloudera

Bei Cloudera glauben wir, dass Daten morgen Dinge ermöglichen werden, die heute noch unmöglich sind. Wir versetzen Menschen in die Lage, komplexe Daten in klare, umsetzbare Erkenntnisse zu transformieren. Wir sind die moderne Plattform für Machine Learning und Analysen, optimiert für die Cloud. Die größten Unternehmen der Welt vertrauen Cloudera bei der Lösung ihrer herausforderndsten, geschäftlichen Probleme. Weitere Informationen finden Sie unter de.cloudera.com/.

Big Data has reduced the boundary between demand-centric dynamic pricing and user-behavior centric pricing!

Real-time pricing is also known as Dynamic pricing, and it is a method to plan and set highly flexible prices of the services or the products. Dynamic pricing is aimed to help the online organizations modify the costs on the fly in relation to the ever changing market conditions. All sorts of modifications are managed the costing bots, who collect the information, and use the algorithms in order to regulate the costing, keeping in mind the set guidelines. With the help of data analysis, vendors can accurately forecast the best prices, and also can adjust it as per the changing needs.

What’s the role of Big Data in Dynamics pricing?

Big data strategies are made just to get the required insights which help to enhance the performance of a business. Still, companies find it difficult to understand the capabilities of analytics, and how the analytics can be used to make the process of pricing all the more powerful. Various levels of Big Data collection, and analysis result into planning a proper dynamics pricing structure. The Big Data captured by the companies hold a lot of value when it comes to devising solid, and very workable dynamics costing structures.

Each and every one of the data-oriented firms move from the basic data reporting stage via a plenty of stages to get to the utmost, desirable level of optimization that’s deemed the most sophisticated. This eventually helps to enhance the revenue management process as well.

How Big Data lessens the gap between demand-centric dynamic pricing and user-behavior centric pricing?

Big Data as we have discussed above has a major role to play when it comes to setting dynamic pricing plans. Dynamic pricing is now further categorized into different segments and two of them are demand-centric dynamic pricing and user-behavior centric pricing. Both of these hold equal importance in creating a top pricing strategy. However, one of the other important things is that, it acts as a liaison between the two as well.  It bridges the gap between the two. When it comes to demand centric costing, it is referred to as what the customer needs, and what the customer is looking for. Whereas, when it comes to user behavior pricing, it is more related to what we should be offering to the customer as per the interest levels of the customers.

Now, both of these parameters hold equal importance when it comes to making costing strategies that are fruitful. To set proper ‘demand centric pricing’ it is importance to know about the demand as well as the wants of the target audience. And, when it comes to user-behavior centric pricing, we need to know how the user is feeling, and what interest areas are. This where the role of Big Data analytics come into play.

Big Data analytics of relative information helps to find out both, the demands and well as the user behaviors. Big Data analytics done to study the target audience are a best way to get to the answers. Once we know about the demands and the user behavior we have to combine both of these to churn our better pricing strategies.

The costing plans should be taken into consideration by mapping both of these elements together. For example, even whenever we curate marketing strategies, they are basically catering to the demands of the public. But, at the same time, user-behavior is never neglected either. It’s a mix of both that we need for setting dynamic prices as well. The modifications which should be done in the pricing should be done based on collective insights gained by clubbing both the elements together.

By studying both the demands graphs as well as the user behavior reports, a company can devise plans that will turn out to be very useful when it comes to costing. Dynamic pricing is as it is a very fruitful invention, and the integration of Big Data has made it all the more powerful.

Big Data is one of those technologies which has made a lot possible in a lot of areas. Be it the pricing structures or the business strategies, Big Data analytics are used everywhere to improve the performance of the company.