Mathematics – Page 2 – Data Science Blog

Applying Data Science Techniques in Python to Evaluate Ionospheric Perturbations from Earthquakes

February 14, 2018/0 Comments/in Data Science, Data Science Hack, Data Science News, Insights, Main Category, Mathematics, Use Cases, Visualization /by Derry Holding

Multi-GNSS (Galileo, GPS, and GLONASS) Vertical Total Electron Content Estimates: Applying Data Science techniques in Python to Evaluate Ionospheric Perturbations from Earthquakes

1 Introduction

Today, Global Navigation Satellite System (GNSS) observations are routinely used to study the physical processes that occur within the Earth’s upper atmosphere. Due to the experienced satellite signal propagation effects the total electron content (TEC) in the ionosphere can be estimated and the derived Global Ionosphere Maps (GIMs) provide an important contribution to monitoring space weather. While large TEC variations are mainly associated with solar activity, small ionospheric perturbations can also be induced by physical processes such as acoustic, gravity and Rayleigh waves, often generated by large earthquakes.

In this study Ionospheric perturbations caused by four earthquake events have been observed and are subsequently used as case studies in order to validate an in-house software developed using the Python programming language. The Python libraries primarily utlised are Pandas, Scikit-Learn, Matplotlib, SciPy, NumPy, Basemap, and ObsPy. A combination of Machine Learning and Data Analysis techniques have been applied. This in-house software can parse both receiver independent exchange format (RINEX) versions 2 and 3 raw data, with particular emphasis on multi-GNSS observables from GPS, GLONASS and Galileo. BDS (BeiDou) compatibility is to be added in the near future.

Several case studies focus on four recent earthquakes measuring above a moment magnitude (MW) of 7.0 and include: the 11 March 2011 MW 9.1 Tohoku, Japan, earthquake that also generated a tsunami; the 17 November 2013 MW 7.8 South Scotia Ridge Transform (SSRT), Scotia Sea earthquake; the 19 August 2016 MW 7.4 North Scotia Ridge Transform (NSRT) earthquake; and the 13 November 2016 MW 7.8 Kaikoura, New Zealand, earthquake.

Ionospheric disturbances generated by all four earthquakes have been observed by looking at the estimated vertical TEC (VTEC) and residual VTEC values. The results generated from these case studies are similar to those of published studies and validate the integrity of the in-house software.

2 Data Cleaning and Data Processing Methodology

Determining the absolute VTEC values are useful in order to understand the background ionospheric conditions when looking at the TEC perturbations, however small-scale variations in electron density are of primary interest. Quality checking processed GNSS data, applying carrier phase leveling to the measurements, and comparing the TEC perturbations with a polynomial fit creating residual plots are discussed in this section.

Time delay and phase advance observables can be measured from dual-frequency GNSS receivers to produce TEC data. Using data retrieved from the Center of Orbit Determination in Europe (CODE) site (ftp://ftp.unibe.ch/aiub/CODE), the differential code biases are subtracted from the ionospheric observables.

2.1 Determining VTEC: Thin Shell Mapping Function

The ionospheric shell height, H, used in ionosphere modeling has been open to debate for many years and typically ranges from 300 – 400 km, which corresponds to the maximum electron density within the ionosphere. The mapping function compensates for the increased path length traversed by the signal within the ionosphere. Figure 1 demonstrates the impact of varying the IPP height on the TEC values.

Figure 1 Impact on TEC values from varying IPP heights. The height of the thin shell, H, is increased in 50km increments from 300 to 500 km.

2.2 Phase Smoothing

For dual-frequency GNSS users TEC values can be retrieved with the use of dual-frequency measurements by applying calculations. Calculation of TEC for pseudorange measurements in practice produces a noisy outcome and so the relative phase delay between two carrier frequencies – which produces a more precise representation of TEC fluctuations – is preferred. To circumvent the effect of pseudorange noise on TEC data, GNSS pseudorange measurements can be smoothed by carrier phase measurements, with the use of the carrier phase smoothing technique, which is often referred to as carrier phase leveling.

Figure 2 Phase smoothed code differential delay

2.3 Residual Determination

For the purpose of this study the monitoring of small-scale variations in ionospheric electron density from the ionospheric observables are of particular interest. Longer period variations can be associated with diurnal alterations, and changes in the receiver- satellite elevation angles. In order to remove these longer period variations in the TEC time series as well as to monitor more closely the small-scale variations in ionospheric electron density, a higher-order polynomial is fitted to the TEC time series. This higher-order polynomial fit is then subtracted from the observed TEC values resulting in the residuals. The variation of TEC due to the TID perturbation are thus represented by the residuals. For this report the polynomial order applied was typically greater than 4, and was chosen to emulate the nature of the arc for that particular time series. The order number selected is dependent on the nature of arcs displayed upon calculating the VTEC values after an initial inspection of the VTEC plots.

3 Results

3.1 Tohoku Earthquake

For this particular report, the sampled data focused on what was retrieved from the IGS station, MIZU, located at Mizusawa, Japan. The MIZU site is 39N 08′ 06.61″ and 141E 07′ 58.18″. The location of the data collection site, MIZU, and the earthquake epicenter can be seen in Figure 3.

Figure 3 MIZU IGS station and Tohoku earthquake epicenter [generated using the Python library, Basemap]

Figure 4 displays the ionospheric delay in terms of vertical TEC (VTEC), in units of TECU (1 TECU = 1016 el m-2). The plot is split into two smaller subplots, the upper section displaying the ionospheric delay (VTEC) in units of TECU, the lower displaying the residuals. The vertical grey-dashed lined corresponds to the epoch of the earthquake at 05:46:23 UT (2:46:23 PM local time) on March 11 2011. In the upper section of the plot, the blue line corresponds to the absolute VTEC value calculated from the observations, in this case L1 and L2 on GPS, whereby the carrier phase leveling technique was applied to the data set. The VTEC values are mapped from the STEC values which are calculated from the LOS between MIZU and the GPS satellite PRN18 (on Figure 4 denoted G18). For this particular data set as seen in Figure 4, a polynomial fit of five degrees was applied, which corresponds to the red-dashed line. As an alternative to polynomial fitting, band-pass filtering can be employed when TEC perturbations are desired. However for the scope of this report polynomial fitting to the time series of TEC data was the only method used. In the lower section of Figure 4 the residuals are plotted. The residuals are simply the phase smoothed delay values (the blue line) minus the polynomial fit line (the red-dashed line). All ionosphere delay plots follow the same layout pattern and all time data is represented in UT (UT = GPS – 15 leap seconds, whereby 15 leap seconds correspond to the amount of leap seconds at the time of the seismic event). The time series shown for the ionosphere delay plots are given in terms of decimal of the hour, so that the format follows hh.hh.

Figure 4 VTEC and residual plot for G18 at MIZU on March 11 2011

3.2 South Georgia Earthquake

In the South Georgia Island region located in the North Scotia Ridge Transform (NSRT) plate boundary between the South American and Scotia plates on 19 August 2016, a magnitude of 7.4 MW earthquake struck at 7:32:22 UT. This subsection analyses the data retrieved from KEPA and KRSA. As well as computing the GPS and GLONASS TEC values, four Galileo satellites (E08, E14, E26, E28) are also analysed. Figure 5 demonstrates the TEC perturbations as computed for the Galileo L1 and L5 carrier frequencies.

Figure 5 VTEC and residual plots at KRSA on 19 August 2016. The plots are from the perspective of the GNSS receiver at KRSA, for four Galileo satellites (a) E08; (b) E14; (c) E24; (d) E26. The y-axes and x-axes in all plots do not conform with one another but are adjusted to fit the data. The y-axes for the residual section of each plot is consistent with one another.

Figure 6 Geometry of the Galileo (E08, E14, E24 and E26) satellites’ projected ground track whereby the IPP is set to 300km altitude. The orange lines correspond to tectonic plate boundaries.

4 Conclusion

The proximity of the MIZU site and magnitude of the Tohoku event has provided a remarkable – albeit a poignant – opportunity to analyse the ocean-ionospheric coupling aftermath of a deep submarine seismic event. The Tohoku event has also enabled the observation of the origin and nature of the TIDs generated by both a major earthquake and tsunami in close proximity to the epicenter. Further, the Python software developed is more than capable of providing this functionality, by drawing on its mathematical packages, such as NumPy, Pandas, SciPy, and Matplotlib, as well as employing the cartographic toolkit provided from the Basemap package, and finally by utilizing the focal mechanism generation library, Obspy.

Pre-seismic cursors have been investigated in the past and strongly advocated in particular by Kosuke Heki. The topic of pre-seismic ionospheric disturbances remains somewhat controversial. A potential future study area could be the utilization of the Python program – along with algorithmic amendments – to verify the existence of this phenomenon. Such work would heavily involve the use of Scikit-Learn in order to ascertain the existence of any pre-cursors.

Finally, the code developed is still retained privately and as of yet not launched to any particular platform, such as GitHub. More detailed information on this report can be obtained here:

Download as PDF

Maschinelles Lernen: Klassifikation vs Regression

December 20, 2017/6 Comments/in Artificial Intelligence, Business Analytics, Data Mining, Data Science, Deep Learning, Machine Learning, Main Category, Mathematics, Predictive Analytics /by Benjamin Aunkofer

Das ist Artikel 2 von 4 aus der Artikelserie – Was ist eigentlich Machine Learning? Die Unterscheidung zwischen Klassifikation und Regression ist ein wichtiger Schritt für das Verständnis von Predictive Analytics. Nun möchte ich eine Erklärung liefern, die den Unterschied (hoffentlich) deutlich macht.

Regression – Die Vorhersage von stetigen Werten

Wir suchen bei der Regression demnach eine Funktion $y = \beta \cdot x + \alpha$ , die unsere Punktwolke – mit der wir uns zutrauen, Vorhersagen über die abhängige Variable vornehmen zu können – möglichst gut beschreibt. Dabei ist $y$ der Zielwert (abhängige Variable) und $x$ der Eingabewert. Wir arbeiten also in einer zwei-dimensionalen Welt. Variablen, die die Funktion mathematisch definieren, werden oft als griechische Buchstaben darsgestellt. Die Variable $\alpha$ (Alpha) ist der $y$ -Achsenschnitt bei $x = 0$ . Dieser wird als Bias, selten auch als Default-Wert, bezeichnet. Der Bias ist also der Wert, wenn die $x$ -Eingabe gleich Null ist. Eine weitere Variable $\beta$ (Beta) beschreibt die Steigung.

Ferner ist zu beachten, dass sich eine Punktwolke durch eine Gerade nie perfekt beschreiben lässt, und daher für jedes $x_{i}$ ein Fehler $\varepsilon_{i}$ existiert. Diesen Fehler wollen wir in diesem Artikel ignorieren.

In einem zwei-dimensionalen System (eine Eingabe und eine Ausgabe) sprechen wir von einer einfachen Regression. Generalisieren wir die Regressionsmethode auf ein multivariates System (mehr als eine Eingabe-Variable), werden die Variablen in der Regel nicht mehr als griechische Buchstaben (denn auch das griechische Alphabet ist endlich) dargestellt, sondern wir nehmen eines abstrahierende Darstellung über Gewichtungen (weights). Dies ist eine sehr treffende Symbolisierungen, denn sowohl der Bias ( $w_{0}$ statt $\alpha$ ) als auch die Steigungen ( $w_{1\ldots n}$ ) sind nichts anderes als Gewichtungen zwischen den Eingaben.

$y = w_{0} \cdot x_{0} + w_{1} \cdot x_{1} + \ldots + w_{n} \cdot x_{n}$

$y$ ist eine Summe aus den jeweiligen Produkten aus $x_{i}$ und $w_{i}$ . Verkürzt ausgedrückt:

$y = \sum_{i=0}^n w_{i} \cdot x_{i}$

Noch kürzer ausgedrückt:

$y = w^T \cdot x$

Anmerkung: Das hochgestellte T steht für Transponieren, eine Notation aus der linearen Algebra, die im Ergebnis nichts anderes bewirkt als $y = \sum_{i=0}^n w_{i} \cdot x_{i}$ .

Diese mathematische lineare Funktion kann wie folgt abgebildet werden:

Der Output ist gleich $y$ bzw. die Ausgabe der Nettoeingabe (Net Sum) $w^T \cdot x$ . Auf der linken Seite finden wir alle Eingabewerte, wobei der erste Wert statisch mit 1.0 belegt ist, nur für den Zweck, den Bias ( $w_{0}$ ) in der Nettoeingabe aufrecht zu erhalten. Im Falle einer einfachen linearen Regression hätten wir also eine Funktion mit zwei Gewichten: $y = 1 \cdot w_{0} + x \cdot w_{1}$

Das Modell beschreibt, wie aus einer Reihe von Eingabewerten (n = Anzahl an x-Dimensionen) und einer Reihe von Gewichtungen (n + 1) eine Funktion entsteht, die einen y-Wert berechnet. Diese Berechnung wird auch als Forward-Propagation bezeichnet.
Doch welche Werte brauchen wir für die Gewichtungen, damit bei gegebenen x-Werten ein (mehr oder weniger) korrekter y-Wert berechnet wird? Anders gefragt, wie schaffen wir es, dass die Forward-Propagation die richtigen Werte ausspuckt?

Mit einem Training via Backpropagation!

Einfache Erklärung der Backpropagation

Die Backpropagation ist ein Optimierungsverfahren, unter Einsatz der Gradientenmethode, den Fehler einer Forward-Propagation zu berechnen und die Gewichtungen in Gegenrichtung des Fehlers anzupassen. Optimiert wird in der Form, dass der Fehler minimiert wird. Es ist ein iteratives Verfahren, bei dem mit jedem Iterationsschritt wieder eine Forward-Propagation auf Basis von Trainingsdaten durchgeführt wird und die Prädiktionsergebnisse mit den vorgegebenen Ergebnissen (der gekennzeichneten Trainingsdaten) verglichen und damit die Fehler berechnet werden. Die resultierende Fehlerfunktion ist konvex, ableitbar und hat ein zentrales globales Minimum. Dieses Minimum finden wir durch diese iterative Vorgehensweise.

Die Backpropagation zu erklären, erfordert einen separaten Artikel. Merken wir uns einfach: Die Backpropagation nutzt eine Fehlerfunktion, um die Werte der Gewichtungen schrittweise entgegen des Fehlers (bei jeder Forward-Propagation) bis zu einem Punkt anzupassen, bis keine wesentliche Verbesserung (Reduzierung des Fehlers) mehr eintritt. Nach dem Vollzug der Backpropagation erhalten wir die “richtigen” Gewichtungen und haben eine Funktion zur Vorhersage von y-Werten bei Eingabe neuer x-Werte.

Klassifikation – Die Vorhersage von Gruppenzugehörigkeiten

Bei der Klassifikation möchten wir jedoch keine Gerade oder Kurve vorhersagen, die sich durch eine Punktwolke legt, sondern wie möchten Punktwolken voneinander als Klassen unterscheiden, um später hinzukommende Punkte ihren richtigen Klassen zuweisen zu können (Klassifikation). Wir können jedoch auf dem vorherigen Modell der Prädiktion von stetigen Werten aufbauen und auch die Backpropagation zum Training einsetzen, möchten das Training dann jedoch auf die Trennung der Punktwolken ausrichten.

Hinweis: Regressions- und Klassifikationsherausforderungen werden in den Dimensionen unterschiedlich dargestellt. Zur Veranschaulichung: Während wir bei der einfachen Regression eine x-Eingabe als unabhängige Variable und eine y-Ausgabe als abhängige Variable haben, haben wir bei einer zwei-dimensionalen Klassifikation zwei x-Dimensionen als Eingabe. Die Klassen sind die y-Ausgabe (hier als Farben visualisiert).

Ergänzen wir das Modell nun um eine Aktivierungsfunktion, dass die stetigen Werte der Nettosumme über eine Funktion in Klassen unterteilt, erhalten wir einen Klassifikator: Den Perceptron-Klassifikator. Das Perzeptron gilt als der einfachste Klassifikator und ist bereits die kleinste Form eines künstlichen neuronalen Netzes. Es funktioniert nur bei linearer Trennbarkeit der Klassen.

Was soll die Aktivierungsfunktion bewirken? Wir berechnen wieder eine Nettoeingabe $w^T \cdot x$ , die uns stetige Werte ausgiebt. Wir haben also immer noch unsere Gewichtungen, die wir trainieren können. Nun trainieren wir nur nicht auf eine “korrekte” stetige Ausgabe der Nettoeingabe hin, sondern auf eine korrekte Ausgabe der Aktivierungsfunktion $\phi$ (Phi), die uns die stetigen Werte der Nettoeingabe in einen binären Wert (z. B. 0 oder 1) umwandelt. Das Perzeptron ist die kleinste Form des künstlichen neuronalen Netzes und funktioniert wie der lineare Regressor, jedoch ergänzt um eine Aktivierungsfunktion die bewirken soll, dass ein Neuron (hier: der einzelne Output) “feuert” oder nicht “feuert”. Es ist ein binärer Klassifikator, der beispielsweise die Wertebereiche -1 oder +1 annehmen kann.

Das Perceptron verwendet die einfachste Form der Aktivierungsfunktion: Eine Sprungfunktion, die einer einfachen if… else… Anweisung gleich kommt.

$y = \phi(w^T \cdot x) = \left\{ \begin{array}{12} 1 & w^T \cdot x > 0\\ -1 & \text{otherwise} \end{array}$

Fazit – Unterschied zwischen Klassifikation und Regression

Mathematisch müssen sich Regression und Klassifikation gar nicht all zu sehr voneinander unterscheiden. Viele Verfahren der Klassifikation lassen sich mit nur wenig Anpassung auch zur Regression anwenden, oder umgekehrt. Künstliche neuronale Netze, k-nächste-Nachbarn und Entscheidungsbäume sind gute Beispiele, die in der Praxis sowohl für Klassifkation als auch für Regression eingesetzt werden, natürlich mit unterschiedlichen Stärken und Schwächen.

Unterschiedlich ist jedoch der Zweck der Anwendung: Bei der Regression möchten wir stetige Werte vorhersagen (z. B. Temperatur der Maschine), bei der Klassifikation hingegen Klassen unterscheiden (z. B. Maschine überhitzt oder überhitzt nicht).

Unterschiede zwischen linearer und nicht-linearer Klassifikation und linearer und nicht-linearer Regression. Für Einsteiger in diese Thematik ist beachten, dass jede maschinell erlernte Klassifikation und Regression einen gewissen Fehler hat, der unter Betrachtung der Trainings- und Testdaten zu minimieren ist, jedoch nie ganz verschwindet.

Und Clustering?

Clustering ist eine Disziplin des unüberwachten Lernens, um Gruppen von Klassen bzw. Grenzen dieser Klassen innerhalb von unbekannten Daten zu finden. Es ist im Prinzip eine untrainierte Klassifikation zum Zwecke des Data Minings. Clustering gehört auch zum maschinellen Lernen, ist aber kein Predictive Analytics. Da keine – mit dem gewünschten Ergebnis vorliegende – Trainingsdaten vorliegen, kann auch kein Training über eine Backpropagation erfolgen. Clustering ist folglich eine schwache Klassifikation, die mit den trainingsbasierten Klassifikationsverfahren nicht funktioniert.

Warenkorbanalyse in R

October 8, 2016/1 Comment/in Business Analytics, Data Mining, Data Science, Data Science Hack, Mathematics, R Statistics, Statistics /by Daniela Keller

Was ist die Warenkorbanalyse?

Die Warenkorbanalyse ist eine Sammlung von Methoden, die die beim Einkauf gemeinsam gekauften Produkte oder Produktkategorien aus einem Handelssortiment untersucht. Ziel der explorativen Warenkorbanalyse ist es, Strukturen in den Daten zu finden, so genannte Regeln, die beschreiben, welche Produkte oder Produktkategorien gemeinsam oder eben nicht gemeinsam gekauft werden.

Beispiel: Wenn ein Kunde Windeln und Bier kauft, kauft er auch Chips.

Werden solche Regeln gefunden, kann das Ergebnis beispielsweise für Verbundplatzierungen im Verkaufsraum oder in der Werbung verwendet werden.

Datenaufbau

Die Daten, die für diese Analyse untersucht werden, sind Transaktionsdaten des Einzelhandels. Meist sind diese sehr umfangreich und formal folgendermaßen aufgebaut:

Ausschnitt eines Beispieldatensatzes: Jede Transaktion (= Warenkorb = Einkauf) hat mehrere Zeilen, die mit der selben Transaktionsnummer (Spalte Transaction) gekennzeichnet sind. In den einzelnen Zeilen der Transaktion stehen dann alle Produkte, die sich in dem Warenkorb befanden. In dem Beispiel sind zudem noch zwei Ebenen von Produktkategorien als zusätzliche Informationen enthalten.

Es gibt mindestens 2 Spalten: Spalte 1 enthält die Transaktionsnummer (oder die Nummer des Kassenbons, im Beispielbild Spalte Transaction), Spalte 2 enthält den Produktnamen. Zusätzlich kann es weitere Spalten mit Infos wie Produktkategorie, eventuell in verschiedenen Ebenen, Preis usw. geben. Sind Kundeninformationen vorhanden, z.B. über Kundenkarten, so können auch diese Informationen enthalten sein und mit ausgewertet werden.

Beschreibende Datenanalyse

Die Daten werden zunächst deskriptiv, also beschreibend, analysiert. Dazu werden z.B. die Anzahl der Transaktionen und die Anzahl der Produkte im Datensatz berechnet. Zudem wird die Länge der Transaktionen, also die Anzahl der Produkte in den einzelnen Transaktionen untersucht. Dies wird mit deskriptiven Maßzahlen wie Minimum, Maximum, Median und Mittelwert in Zahlen berichtet sowie als Histogramm grafisch dargestellt, siehe folgende Abbildung.

Histogramm der Längenverteilung der Transaktionen.

Die häufigsten Produkte werden ermittelt und können gesondert betrachtet werden. Als Visualisierung kann hier ein Balkendiagramm mit den relativen Häufigkeiten der häufigsten Produkte verwendet werden, wie im folgenden Beispiel.

Relative Häufigkeiten der häufigsten Produkte, hier nach relativer Häufigkeit größer 0,1 gefiltert.

Ähnliche Analysen können bei Bedarf auch auf Kategorien-Ebene oder nach weiteren erhobenen Merkmalen selektiert durchgeführt werden, je nachdem, welche Informationen in den Daten stecken und welche Fragestellungen für den Anwender interessant sind.

Verbundanalyse

Im nächsten Schritt wird mit statistischen Methoden nach Strukturen in den Daten gesucht, auch Verbundanalyse genannt. Als Grundlage werden Ähnlichkeitsmatrizen erstellt, die für jedes Produktpaar die Häufigkeit des gemeinsamen Vorkommens in Transaktionen bestimmen. Solch eine Ähnlichkeitsmatrix ist zum Beispiel eine Kreuztabelle in der es für jedes Produkt eine Spalte und eine Zeile gobt. In den Zellen in der Tabelle steht jeweils die Häufigkeit, wie oft dieses Produktpaar gemeinsam in Transaktionen in den Daten vorkommt, siehe auch folgendes Beispiel.

Ähnlichkeitsmatrix oder Kreuztabelle der Produkte: Frankfurter und Zitrusfrüchte werden in 64 Transaktionen zusammen gekauft, Frankfurter und Berries in 22 usw.

Auf Basis solch einer Ähnlichkeitsmatrix wird dann z.B. mit Mehrdimensionaler Skalierung oder hierarchischen Clusteranalysen nach Strukturen in den Daten gesucht und Gemeinsamkeiten und Gruppierungen gefunden. Die hierarchische Clusteranalyse liefert dann ein Dendrogram, siehe folgende Abbildung, in der ähnliche Produkte miteinander gruppiert werden.

Dendrogram als Visualisierung des Ergebnisses der hierarchischen Clusterananlyse. Ähnliche Produkte (also Produkte, die zusammen gekauft werden) werden zusammen in Gruppen geclustert. Je länger die vertikale Verbindungslinie ist, die zwei Gruppen oder Produkte zusammen fasst, um so unterschiedlicher sind diese Produkte bzw. Gruppen.

Assoziationsregeln

Schließlich sollen neben den Verbundanalysen am Ende in den Daten Assoziationsregeln gefunden werden. Es werden also Regeln gesucht und an den Daten geprüft, die das Kaufverhalten der Kunden beschreiben. Solch eine Regel ist zum Beispiel „Wenn ein Kunde Windeln und Bier kauft, kauft er auch Chips.“ Formal: {Windeln, Bier} → {Chips}

Für diese Regeln lassen sich statistische Maßzahlen berechnen, die die Güte und Bedeutung der Regeln beschreiben. Die wichtigsten Maßzahlen sind Support, Confidence und Lift:

Support ist das Signifikanzmaß der Regel. Es gibt an, wie oft die gefundene Regel in den Daten anzuwenden ist. Wie oft also die in der Regel enthaltenen Produkte gemeinsam in einer Transaktion vorkommen. In dem Beispiel oben: Wie oft kommen Windeln, Bier und Chips in einer Transaktion gemeinsam vor?

Confidence ist das Qualitätsmaß der Regel. Es beschreibt, wie oft die Regel richtig ist. In dem oben genanten Beispiel: Wie oft ist in einer Transaktion Chips enthalten, wenn auch Windeln und Bier enthalten sind?

Lift ist das Maß der Bedeutung der Regel. Es sagt aus wie oft die Confidence den Erwartungswert übersteigt. Wie ist die Häufigkeit des gemeinsamen Vorkommens von Windeln, Bier und Chips im Verhältlnis zur erwarteten Häufigkeit des Vorkommens, wenn die Ereignisse stochastisch unabhängig sind?

Algorithmen

In den Daten werden zunächst alle möglichen Regeln gesammelt, die einen Mindestwert an Support und Confidence haben. Die Mindestwerte werden dabei vom Nutzer vorgegeben. Da es sich bei Transaktionsdaten um große Datenmengen handelt und häufig große Anzahlen von Produkten enthalten sind, wird die Suche nach Regeln zu einem komplexen Problem. Es wurden verschiedene effiziente Algorithmen als Suchstrategien entwickelt, z.B. der APRIORI-Algorithmus von Agrawal und Srikant (1994), der auch im weiter unten vorgestellten Paket arules von R verwendet wird.

Sind die Assoziationsregeln gefunden, können Sie vom Nutzer genauer untersucht werden und z.B. nach den oben genannten Kennzahlen sortiert betrachtet werden, oder es werden die Regeln für spezielle Warenkategorien genauer betrachtet, siehe folgendes Beispiel.

Beispielausgabe von Regeln, hier die drei Regeln mit dem besten Lift. In der ersten Regel sieht man: Wenn Bier und Wein gekauft wird, wird auch Likör gekauft. Diese Regel hat einen Support von 0,002. Diese drei Produkte kommen also in 0,2 % der Transaktionen vor. Die Confidence von 0,396 zeigt, dass in 39,6 % der Transaktionen auch Likör gekauft wird, wenn Bier und Wein gekauft wird.

Umsetzung mit R

Die hier vorgestellten Methoden zur Warenkorbanalyse lassen sich mit dem Paket arules der Software R gut umsetzen. Im Folgenden gebe ich eine Liste von nützlichen Befehlen für diese Analysen mit dieser Software. Dabei wird mit data hier durchgehend der Datensatz der Transaktionsdaten bezeichnet.

1	summary(data)

Zusammenfassung des Datensatzes:

Anzahl der Transaktionen und Anzahl der Warengruppen
die häufigsten Produkte werden genannt mit Angabe der Häufigkeiten
Längenverteilung der Transaktionen (Anzahl der Produkte pro Transaktion): Häufigkeiten, deskriptive Maße wie Quartile
Beispiel für die Datenstruktur (Levels)

1	size(data)

Längen der Transaktionen (Anzahl der Produkte pro Transaktion)

1	hist(size(data))

Histogramm als grafische Darstellung der Transaktionslängen

1	itemFrequencyPlot(data, support=0.1)

rel. Häufigkeiten der einzelnen Produkte, hier nur die mit mindestens 10 % Vorkommen

1	crossTable(data)

Äquivalenzmatrix: Häufigkeiten der gemeinsamen Käufe für Produktpaare

1	dissJacc <- dissimilarity(data[, itemFrequency(data) > 0.05], method = "Jaccard", which = "items")

Unähnlichkeitsmatrix für die hierarchische Clusteranalyse

1	hcWard <- hclust(dissJacc, method = "ward.D")

Hierarchische Clusteranalyse

1	plot(hcWard)

Dendrogram der hierarchischen Clusteranalyse

1 2	rules <- apriori(data, parameter = list(support = 0.001, confidence = 0.2), control = list(verbose = FALSE))

Assoziationsregeln finden mit APRIORI-Algorithmus, hier Regeln mit mindestens 1% Support und 20 % Confidence

1	summary(rules)

Zusammenfassung der oben gefundenen Regeln (Anzahl, Eigenschaften Support, Confidence, Lift)

1	inspect(SORT(rules,by=“lift“)[1:5])

Einzelne Regeln betrachten, hier die laut Lift besten 5 Regeln

Referenzen:

Michael Hahsler, Kurt Hornik, Thomas Reutterer: Warenkorbanalyse mit Hilfe der Statistik-Software R, Innovationen in Marketing, S.144-163, 2006.
Michael Hahsler, Bettina Grün, Kurt Hornik, Christian Buchta, Introduciton to arules – A computational environment for mining association rules and frequent item sets. (Link zum PDF)
Rakesh Agrawal, Ramakrishnan Srikant, Fast algorithms for mining association rules, Proceedings of the 20th VLDB Conference Santiago, Chile, 1994
Software R: R Core Team (2016). R: A language and environment for statistical computing. R Foundation for Statistical Computing, Vienna, Austria. Link: R-Project.org.
Paket: arules: Mining Association Rules using R.

Beispieldatensatz: Groceries aus dem Paket arules

Benford-Analyse

September 21, 2016/1 Comment/in Audit Analytics, Mathematics, Python, Statistics, Tutorial /by Benjamin Aunkofer

Das Benfordsche Gesetz beschreibt eine Verteilung der Ziffernstrukturen von Zahlen in empirischen Datensätzen. Dieses Gesetz, welches kein striktes Naturgesetz ist, sondern eher ein Erklärungsversuch in der Natur und in der Gesellschaft vorkommende Zahlenmuster vorherzusagen.

Das Benfordsche Gesetz beruht auf der Tatsache, dass die Ziffern in einem Zahlensystem hierarchisch aufeinander aufbauen: Es beginnt mit der 1, dann folgt die 2, dann die 3 usw. In Kombination mit bestimmten Gesetzen der Natur (der natürliche Wachstumsprozess, dabei möglichst energiesparend wachsen/überleben) oder Ökonomie (so günstig wie möglich einkaufen) ist gemäß des Benfordschen Gesetz zu erwarten, dass die Ziffer 1 häufiger vorkommt als die 2, die wiederum häufiger vorkommt als die 3. Die Ziffer 9 braucht demnach den längsten Weg und kommt entsprechend verhältnismäßig seltener vor.

Dieses Phönomen hilft uns bei echten Zufallszahlen nicht weiter, denn dann sind alle Ziffern nicht aufeinander aufbauend, sondern mehr oder weniger gleichberechtigt in ihrem Auftrauen. Bei der klassischen und axiomatischen Wahrscheinlichkeit kommen wir damit also nicht ans Ziel.

Die Benford-Analyse ist im Grunde eine Ausreißeranalyse: Wir vergleichen Ziffernmuster in Datenbeständen mit der Erwartungshaltung des Benfordschen Gesetzes. Weicht das Muster von dieser Erwartung ab, haben wir Diskussionsbedarf.

Moderne Zahlensysteme sind Stellenwert-Zahlensysteme. Neben den Dual-, Oktal- und Hexadezimalzahlensystemen, mit denen sich eigentlich nur Informatiker befassen, wird unser Alltag vom Dezimalzahlensystem geprägt. In diesem Zahlensystem hat jede Stelle die Basis 10 (“dezi”) und einen Exponenten entsprechend des Stellenwertes, multipliziert mit der Ziffer d. Es ist eine Exponentialfunktion, die den Wert der Ziffern in bestimmter Reihenfolge ermittelt:

$Z =\sum_{i=-n}^{m}d_{i}\cdot10^{i}$

Die Benford-Analyse wird meistens nur für die erste Ziffer (also höchster Stellenwert!) durchgeführt. Dies werden wir gleich einmal beispielhaft umsetzen.

Die Wahrscheinlichkeit des Auftretens der ersten “anführenden” Ziffer d ist ein Logarithmus zur Basis B. Da wir im alltäglichen Leben – wie gesagt – nur im Dezimalzahlensystem arbeiten, ist für uns B = 10.

$p(d)=\log_{B}\left( 1 +\frac{1}{d} \right)$

Im Standard-Python lässt sich diese Formel leicht mit einer Schleife umsetzen:

import math

[round(math.log10(1+1/float(i))*100.0, 2) for i in range(1,10)]

Out: [30.1, 17.61, 12.49, 9.69, 7.92, 6.69, 5.8, 5.12, 4.58]

Benford-Algorithmus in Python mit NumPy und Pandas

Nachfolgend setzen wir eine Benford-Analyse als Minimalbeispiel in NumPy und Pandas um.

import numpy as np

x = np.arange(1,10) # NumPy-Array erstellen

Out: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9])

benford = np.round(np.log10(1+1/x) * 100.0, decimals=2) # Den Logarithmus auf das NumPy-Array anwenden und runden

Out: array([ 30.1 , 17.61, 12.49, 9.69, 7.92, 6.69, 5.8 , 5.12,

4.58])

Nun möchten wir eine Tabelle erstellen, mit zwei Spalten, eine für die Ziffer (Digit), die andere für die relative Häufigkeit der Ziffer (Benford Law). Dazu nutzen wir das DataFrame aus dem Pandas-Paket. Das DataFrame erstellen wir aus den zwei zuvor erstellten NumPy-Arrays.

import pandas as pd

benfordFrame = pd.DataFrame({'Digit': x, 'Benford Law': benford})

benfordFrame

Out:

Benford Law Digit

0 30.10 1

1 17.61 2

2 12.49 3

3 9.69 4

4 7.92 5

5 6.69 6

6 5.80 7

7 5.12 8

8 4.58 9

Man könnte sicherlich auch den natürlichen Index des DataFrames nutzen, indem wir diesen nur um jeweils 1 erhöhen, aber das verwirrt später nur und tun wir uns jetzt daher lieber nicht an…

1 2	benfordFrame.plot('Digit', 'Benford Law', kind='bar', title='Benford', legend=False)

Das Dataframe-Objekt kann direkt plotten (das läuft über die matplotlib, die wir aber nicht direkt einbinden müssen):

Diese neun Balken zeigen die Verteilung der Ziffernhäufigkeit nach dem Benfordschen Gesetz, diese Verteilung ist unsere Erwartungshaltung an andere nummerische Datenbestände, wenn diese einem natürlichen Wachstum unterliegen.

Analyse der Verteilung der ersten Ziffer in Zahlungsdaten

Jetzt brauchen wir Daten mit nummerischen Beträgen, die wir nach Benford testen möchten. Für dieses Beispiel nehme ich aus einem ein SAP-Testdatensatz die Spalte ‘DMBTR’ der Tabelle ‘BSEG’ (SAP FI). Die Spalte ‘DMBTR’ steht für “Betrag in Hauswährung’, die ‘BSEG’ ist die Tabelle für die buchhalterischen Belegsegmente.
Die Datei mit den Testdaten ist über diesen Link zum Download verfügbar (Klick) und enthält 40.000 Beträge.

Wir laden den Inhalt der Datei via NumPy.LoadTxt() und machen aus dem resultierenden NumPy-Array wieder ein Pandas.DataFrame und holen uns die jeweils erste Ziffer für alle Einträge als Liste zurück.

financialTransactions = np.loadtxt("[DEIN LOKALER PFAD]\\BSEG_DMBTR.csv", skiprows=1)

financialTransactionsFrame = pd.DataFrame({'Zahlungen':financialTransactions})

firstDigits = [str(value)[0:1] for value in financialTransactionsFrame['Zahlungen']]

Die Einträge der ersten Ziffer in firstDigits nehmen wir uns dann vor und gruppieren diese über die Ziffer und ihrer Anzahl relativ zur Gesamtanzahl an Einträgen.

percentDigits = np.asarray([[i, firstDigits.count(str(i))/float(len(financialTransactionsFrame['Zahlungen']))*100] for i in range(1, 10)])

percentDigits.T[1].sum()

Out: 94.0

Wenn wir die Werte der relativen Anzahl aufsummieren, landen wir bei 94% statt 100%. Dies liegt daran, dass wir die Ziffer 0 ausgelassen haben, diese jedoch tatsächlich vorkommt, jedoch nur bei Beträgen kleiner 1.00. Daher lassen wir die Ziffer 0 außenvor. Wer jedoch mehr als nur die erste Ziffer prüfen möchte, wird die Ziffer 0 wieder mit in die Betrachtung nehmen wollen. Nur zur Probe nocheinmal mit der Ziffer 0, so kommen wir auf die 100% der aufsummierten relativen Häufigkeiten:

percentDigits = np.asarray([[i, firstDigits.count(str(i))/float(len(financialTransactionsFrame['Zahlungen']))*100] for i in range(0, 10)])

percentDigits.T[1].sum()

Out: 100.0

Nun erstellen wir ein weiteres Pandas.DataFrame, mit zwei Spalten: Die Ziffern (Digit) und die tatsächliche Häufigkeit in der Gesamtpopulation (Real Distribution):

1 2	percentDigitsFrame = pd.DataFrame({'Digit':percentDigits[:,0], 'Real Distribution':percentDigits[:,1]})

Abgleich der Ziffernhäufigkeit mit der Erwartung

Nun bringen wir die theoretische Verteilung der Ziffern, also nach dem zuvor genannten Logarithmus, und die tatsächliche Verteilung der ersten Ziffern in unseren Zahlungsdaten in einem Plot zusammen:

import matplotlib.pyplot as pyplot

fig = pyplot.figure()

ax = fig.add_subplot(111)

ax2 = ax.twinx()

percentDigitsFrame.plot('Digit', 'Real Distribution', kind='bar', ax=ax2, width = 0.4, color="green", position=0, legend=False)

benfordFrame.plot('Digit', 'Benford Law', kind='bar', ax=ax, width = 0.4, color="blue", position=1, legend=False)

lines, labels = ax.get_legend_handles_labels()

lines2, labels2 = ax2.get_legend_handles_labels()

ax2.legend(lines + lines2, labels + labels2, loc=0)

ax.set_ylim(1,35)

ax2.set_ylim(1,35)

pyplot.show()

In dem Plot wird deutlich, dass die Verteilung der führenden Ziffer in unseren Zahlungsdaten in ziemlich genau unserer Erwartung nach dem Benfordschen Gesetz entspricht. Es sind keine außerordentlichen Ausreißer erkennbar. Das wäre auch absolut nicht zu erwarten gewesen, denn der Datensatz ist mit 40.000 Einträgen umfassend genug, um dieses Muster gut abbilden zu können und von einer Manipulation dieser Beträge im SAP ist ebenfalls nicht auszugehen.

Gegenüberstellung: Computer-generierte Zufallszahlen

Jetzt wollen wir nochmal kurz darauf zurück kommen, dass das Benfordsche Gesetz für Zufallszahlen nicht unwendbar ist. Bei echten Zufallszahlen bin ich mir da auch sehr sicher. Echte Zufallszahlen ergeben sich beispielweise beim Lotto, wenn die Bälle mit Einzel-Ziffern durch eine Drehkugel hüpfen. Die Lottozahl-Ermittlung erfolgt durch die Zusammenstellung von jeweils gleichberechtigt erzeugten Ziffern.
Doch wie ist dies bei vom Computer generierten Zufallszahlen? Immerhin heißt es in der Informatik, dass ein Computer im Grunde keine Zufallszahlen erzeugen kann, sondern diese via Takt und Zeit erzeugt und dann durchmischt. Wir “faken” unsere Zahlungsdaten nun einfach mal via Zufallszahlen. Hierzu erstellen wir in NumPy ein Array mit 2000 Einträgen einer Zufallszahl (NumPy.Random.rand(), erzeugt floats 0.xxxxxxxx) und multiplizieren diese mit einem zufälligen Integer (Random.randint()) zwischen 0 und 1000.

from random import randint

financialTransactions = np.round(np.random.rand(2000) * randint(0,1000),decimals=2) # Zufallszahlen erzeugen, die auf dem ersten Blick als Zahlungsdaten durchgehen :-)

Erzeugen wir die obigen Datenstrukturen erneut, zeigt sich, dass die Verteilung der Zufallszahlen ganz anders aussieht: (vier unterschiedliche Durchläufe)

Anwendung in der Praxis

Data Scientists machen sich das Benfordsche Gesetz zu Nutze, um Auffälligkeiten in Zahlen aufzuspüren. In der Wirtschaftsprüfung und Forensik ist diese Analyse-Methode recht beliebt, um sich einen Eindruck von nummerischen Daten zu verschaffen, insbesondere von Finanztransaktionen. Die Auffälligkeit durch Abweichung vom Benfordchen Gesetz entsteht z. B. dadurch, dass Menschen eine unbewusste Vorliebe für bestimmte Ziffern oder Zahlen haben. Greifen Menschen also in “natürliche” Daten massenhaft (z. B. durch Copy&Paste) ein, ist es wahrscheinlich, dass sie damit auch vom Muster des Benfordschen Gesetzes abweichen. Weicht das Muster in Zahlungsströmen vom Bendfordsche Erwartungsmuster für bestimmte Ziffern signifikant ab, könnte dies auf Fälle von unnatürlichen Eingriffen hindeuten.

Die Benford-Analyse wird auch gerne eingesetzt, um Datenfälschungen in wissenschaftlichen Arbeiten oder Bilanzfälschungen aufzudecken. Die Benford-Analyse ist dabei jedoch kein Beweis, sondern liefert nur die Indizien, die Detailanalysen nach sich ziehen können/müssen.

Die Rastrigin-Funktion

September 15, 2016/0 Comments/in Mathematics, optimization, Python, Tutorial, Visualization /by Benjamin Aunkofer

Jeder Data Scientist kommt hin und wieder mal in die Situation, einen Algorithmus trainieren bzw. optimieren zu wollen oder zu müssen, ohne jedoch, dass passende Trainingsdaten unmittelbar verfügbar wären. Zum einen kann man in solchen Fällen auf Beispieldaten zugreifen, die mit vielen Analysetools mitgeliefert werden, oder aber man generiert sich seine Daten via mathematischer Modelle selbst, die für bestimmte Eigenschaften bekannt sind, die gute Bedingungen für das Optimierungstraining liefern.

Ein solches Modell, das man als Machine Learning Entwickler kennen sollte, ist die Rastrigin-Funktion, die laut Wikipedia von Leonard A. Rastrigin erstmalig beschrieben wurde. Dabei handelt es sich um eine Häufigkeites-/Wahrscheinlichkeitsverteilung, deren Dichte mehrere lokale Modi (Gipfel) aufweist. Ein Modus (oder Modalwert) ist in einer Häufigkeitsverteilung der häufigste Wert (“Bergspitze”) bzw. der Wert mit der höchsten Wahrscheinlichkeit.

Anmerkung des Autors: Dieser Artikel stellt zum einen die Rastrigin-Funktion und ihre Bedeutung für die Optimierungsrechnung vor, ist zum anderen aber auch eine Einführung in den Umgang mit NumPy-Matrizen (die eine Menge For-Schleifen ersparen können).

Die Rastrigin-Funktion

Mathematisch beschrieben wird die Rastrigin-Funktion wie folgt:

$f(x_1 \cdots x_n) = An + \sum_{i=1}^n (x_i^2 -10cos(2\pi x_i))$

$-5.12 \leq x_i \leq 5.12$

Wobei für das globale Minimum gilt: $f(0) = 0$
Außerdem ist zu beachten, dass $A=10$ eine Konstante ist.

Die Rastrigin-Funktion im Standard-Python umsetzen und visualisieren

Die Formel lässt sich in Python (wie natürlich in jeder anderen Programmiersprache auch) einfach umsetzen:

1	value = 10 + x*2 - 10 math.cos(2 * math.pi * x)

Nun können wir über den klassischen Weg der Programmierung einfach eine For-Schleife verwenden, um die Rastrigin-Funktionswerte in eine Liste zu packen und mit einem Plot zu visualsieren, dabei bin ich leider doch nicht ganz um die Verwendung des NumPy-Pakets nicht herumgekommen:

import matplotlib.pyplot as pyplot

import numpy as np # NumPy hat die Matrizen-Datenstruktur, die wir benötigen

import math as math # Grundlegende mathematische Funktionen (hier benötigt: Kreiszahl Pi und Cosinus-Funktion)

rastriginValues = []

i = 0

for x in np.arange(-5.12, 5.12, 0.01): # Die Python-eigene range()-Funktion kann leider keine Floats, sondern nur Integer erzeugen :-/

value = 10 + x**2 - 10 * math.cos(2 * math.pi * x)

i += 1

print(i, x, value)

rastriginValues.append(value)

pyplot.plot(rastriginValues)

pyplot.ylim(0,50)

pyplot.xlim(0,1024)

pyplot.show()

Die grafische Darstellung zeigt, dass es sich tatsächlich um eine symmetrische multimodalen Verteilung handelt.

Die Rastrigin-Funktion mehrdimensional umsetzen, mit NumPy-Matrizen-Funktionen

Die obige Umsetzung der Rastrigin-Funktion ist eindimensional (eine Variable), braucht für die Darstellung allerdings zwei Dimensionen (f(x) und die Durchlaufanzahl bzw. Zeitachse). Nun könnten wir die Zahl der Variablen von 1 (x) auf 2 (x und y) erhöhen und eine dreidimensionale Darstellung erzeugen. Eine ähnliche dreidimensionale Darstellung gab es bereits in meiner Vorstellung des k-nearest-Neighbour-Algorithmus nachzuvollziehen. Dabei müssten wir die Konstante $A=10$ auf $A=20$ verdoppeln:

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as pyplot

import numpy as np

figure = pyplot.figure()

axe = figure.add_subplot(111, projection='3d')

x = np.linspace(-5.12, 5.12, 100) # unterteilt den Bereich in 100 Schnitte, ähnlich: np.arange(-5.12, 5.12, 0.1)

y = np.linspace(-5.12, 5.12, 100)

x, y = np.meshgrid(x, y) # erzeugt ein Koordinatensystem

# Nun ohne Schleifen: Wir wenden die NumPy-Funktionen (np.cos statt math.cos und np.pi statt math.pi)

# auf die NumPy-Arrays an (x und y) und erhalten ein NumPy-Array z zurück

z = 20 + x**2 - 10 * np.cos(2 * np.pi * x) + y**2 - 10 * np.cos(2* np.pi * y)

# Plotte die drei Variablen (x, y, z) im dreidimensionalen Raum

axe.plot_surface(x, y, z, rstride=1, cstride=1, cmap="jet", linewidth=0, antialiased=False)

pyplot.title('Rastrigin-Map')

pyplot.grid(True)

axes = pyplot.gca()

axes.set_xlim([-5.12,5.12])

axes.set_ylim([-5.12,5.12])

pyplot.show()

Die Rastrigin-Funktion wird gerne für Optimierungsalgorithmen eingesetzt, wofür sie wegen des großen Suchraums und der hohen Anzahl lokaler Modi ein herausforderndes Umfeld bietet. Beispielsweise wird – meines Erachtens nach – das wohl beliebteste Optimierungsverfahren im maschinellen Lernen, das Gradientenverfahren, hier keine guten Ergebnisse liefern, denn es gibt einfach zu viele lokale Minima.

Machine Learning mit Python – Minimalbeispiel

April 26, 2016/25 Comments/in Artificial Intelligence, Data Mining, Data Science Hack, Machine Learning, Mathematics, optimization, Predictive Analytics, Python, Tutorial, Visualization /by Benjamin Aunkofer

Maschinelles Lernen (Machine Learning) ist eine Gebiet der Künstlichen Intelligenz (KI, bzw. AI von Artificial Intelligence) und der größte Innovations- und Technologietreiber dieser Jahre. In allen Trendthemen – wie etwa Industrie 4.0 oder das vernetzte und selbstfahrende Auto – spielt die KI eine übergeordnete Rolle. Beispielsweise werden in Unternehmen viele Prozesse automatisiert und auch Entscheidungen auf operativer Ebene von einer KI getroffen, zum Beispiel in der Disposition (automatisierte Warenbestellungen) oder beim Festsetzen von Verkaufspreisen.

Aufsehen erregte Google mit seiner KI namens AlphaGo, einem Algortihmus, der den Weltmeister im Go-Spiel in vier von fünf Spielen besiegt hatte. Das Spiel Go entstand vor mehr als 2.500 Jahren in China und ist auch heute noch in China und anderen asiatischen Ländern ein alltägliches Gesellschaftsspiel. Es wird teilweise mit dem westlichen Schach verglichen, ist jedoch einfacher und komplexer zugleich (warum? das wird im Google Blog erläutert). Machine Learning kann mit einer Vielzahl von Methoden umgesetzt werden, werden diese Methoden sinnvoll miteinander kombiniert, können durchaus äußerst komplexe KIs erreicht werden. Der aktuell noch gängigste Anwendungsfall für Machine Learning ist im eCommerce zu finden und den meisten Menschen als die Produktvorschläge von Amazon.com bekannt: Empfehlungsdienste (Recommender System).

Klassifikation via K-Nearest Neighbour Algorithmus

Ein häufiger Zweck des maschinellen Lernens ist, technisch gesehen, die Klassifikation von Daten in Abhängigkeit von anderen Daten. Es gibt mehrere ML-Algorithmen, die eine Klassifikation ermöglichen, die wohl bekannteste Methode ist der k-Nearest-Neighbor-Algorithmus (Deutsch:„k-nächste-Nachbarn”), häufig mit “kNN” abgekürzt. Das von mir interviewte FinTech StartUp Number26 nutzt diese Methodik beispielsweise zur Klassifizierung von Finanztransaktionen.

Um den Algorithmus Schritt für Schritt aufbauen zu können, müssen wir uns

Natürlich gibt es in Python, R und anderen Programmiersprachen bereits fertige Bibliotheken, die kNN bereits anbieten, denen quasi nur Matrizen übergeben werden müssen. Am bekanntesten ist wohl die scikit-learn Bibliothek für Python, die mehrere Nächste-Nachbarn-Modelle umfasst. Mit diesem Minimalbeispiel wollen wir den grundlegenden Algorithmus von Grund auf erlernen. Wir wollen also nicht nur machen, sondern auch verstehen.

Vorab: Verwendete Bibliotheken

Um den nachstehenden Python-Code (Python 3.x, sollte allerdings auch mit Python 2.7 problemlos funktionieren) ausführen zu können, müssen folgende Bibliotheken eingebunden werden:

import numpy as numpy

import matplotlib.pyplot as pyplot

from mpl_toolkits.mplot3d import Axes3D #Erweiterung für die Matplotlib - siehe: http://matplotlib.org/mpl_toolkits/

Übrigens: Eine Auflistung der wohl wichtigsten Pyhton-Bibliotheken für Datenanalyse und Datenvisualisierung schrieb ich bereits hier.

Schritt 1 – Daten betrachten und Merkmale erkennen

Der erste Schritt ist tatsächlich der aller wichtigste, denn erst wenn der Data Scientist verstanden hat, mit welchen Daten er es zu tun hat, kann er die richtigen Entscheidungen treffen, wie ein Algorithmus richtig abgestimmt werden kann und ob er für diese Daten überhaupt der richtige ist.

In der Realität haben wir es oft mit vielen verteilten Daten zu tun, in diesem Minimalbeispiel haben wir es deutlich einfacher: Der Beispiel-Datensatz enthält Informationen über Immobilien über vier Spalten.

Quadratmeter: Größe der nutzbaren Fläche der Immobilie in der Einheit m²
Wandhoehe: Höhe zwischen Fußboden und Decke innerhalb der Immobilie in der Einheit m
IA_Ratio: Verhältnis zwischen Innen- und Außenflächen (z. B. Balkon, Garten)
Kategorie: Enthält eine Klassifizierung der Immobilie als “Haus”, “Wohnung” und “Büro”

[box]Hinweis für Python-Einsteiger: Die Numpy-Matrix ist speziell für Matrizen-Kalkulationen entwickelt. Kopfzeilen oder das Speichern von String-Werten sind für diese Datenstruktur nicht vorgesehen![/box]

def readDataSet(filename):

fr = open(filename) # Datei-Stream vorbereiten

numberOfLines = len(fr.readlines()) # Anzahl der Zeilen ermitteln

returnMat = numpy.zeros((numberOfLines-1,3)) # Eine Numpy-Matrix in Höhe der Zeilenanzahl (minus Kopfzeile) und in Breite der drei Merkmal-Spalten

classLabelVector = [] # Hier werden die tatsächlichen Kategorien (Haus, Wohnung, Büro) vermerkt

classColorVector = [] # Hier werden die Kategorien über Farben vermerkt (zur späteren Unterscheidung im 3D-Plot!)

#print(returnMat) # Ggf. mal die noch die ausge-null-te Matrix anzeigen lassen (bei Python 2.7: die Klammern weglassen!)

fr = open(filename) # Datei-Stream öffnen

index = 0

for line in fr.readlines(): # Zeile für Zeile der Datei lesen

if index != 0: # Kopfzeile überspringen

line = line.strip()

listFromLine = line.split('\t') # Jede Zeile wird zur temporären Liste (Tabulator als Trennzeichen)

returnMat[index-1,:] = listFromLine[1:4] #Liste in die entsprechende Zeile der Matrix überführen

classLabel = listFromLine[4] # Kategorie (Haus, Wohnung, Büro) für diese Zeile merken

if classLabel == "Buero":

color = 'yellow'

elif classLabel == "Wohnung":

color = 'red'

else:

color = 'blue'

classLabelVector.append(classLabel) # Kategorie (Haus, Wohnung, Büro) als Text-Label speichern

classColorVector.append(color) # Kategorie als Farbe speichern (Büro = gelb, Wohnung = rot, Haus = Blau)

index += 1

return returnMat,classLabelVector, classColorVector

Aufgerufen wird diese Funktion dann so:

1 2	dataSet, classLabelVector, classColorVector = readDataSet("K-Nearst_Neighbour-DataSet.txt")

Die Matrix mit den drei Spalten (Quadratmeter, Wandhohe, IA_Ratio) landen in der Variable “dataSet”.

Schritt 2 – Merkmale im Verhältnis zueinander perspektivisch betrachten

Für diesen Anwendungsfall soll eine Klassifizierung (und gewissermaßen die Vorhersage) erfolgen, zu welcher Immobilien-Kategorie ein einzelner Datensatz gehört. Im Beispieldatensatz befinden sich vier Merkmale: drei Metriken und eine Kategorie (Wohnung, Büro oder Haus). Es stellt sich zunächst die Frage, wie diese Merkmale zueinander stehen. Gute Ideen der Datenvisualisierung helfen hier fast immer weiter. Die gängigsten 2D-Visualisierungen in Python wurden von mir bereits hier zusammengefasst.

[box]Hinweis: In der Praxis sind es selten nur drei Dimensionen, mit denen Machine Learning betrieben wird. Das Feature-Engineering, also die Suche nach den richtigen Features in verteilten Datenquellen, macht einen wesentlichen Teil der Arbeit eines Data Scientists aus – wie auch beispielsweise Chief Data Scientist Klaas Bollhoefer (siehe Interview) bestätigt.[/box]

fig = pyplot.figure()

ax = fig.add_subplot(111)

ax.scatter(dataSet[:,0], dataSet[:,1], marker='o', color=classColorVector)

ax.set_xlabel("Raumflaeche in Quadratmeter")

ax.set_ylabel("Wandhohe")

ax.set_xlim(xmin=0)

ax.set_ylim(ymin=0)

pyplot.show()

fig = pyplot.figure()

ax = fig.add_subplot(111)

ax.scatter(dataSet[:,0], dataSet[:,2], marker='o', color=classColorVector)

ax.set_xlabel("Raumflaeche in Quadratmeter")

ax.set_ylabel("IA_Ratio")

ax.set_xlim(xmin=0)

ax.set_ylim(ymin=0)

pyplot.show()

Die beiden Scatter-Plots zeigen, das Häuser (blau) in allen Dimensionen die größte Varianz haben. Büros (gelb) können größer und höher ausfallen, als Wohnungen (rot), haben dafür jedoch tendenziell ein kleineres IA_Ratio. Könnten die Kategorien (blau, gelb, rot) durch das Verhältnis innerhalb von einem der beiden Dimensionspaaren in dem zwei dimensionalen Raum exakt voneinander abgegrenzt werden, könnten wir hier stoppen und bräuchten auch keinen kNN-Algorithmus mehr. Da wir jedoch einen großen Überschneidungsbereich in beiden Dimensionspaaren haben (und auch Wandfläche zu IA_Ratio sieht nicht besser aus),

Eine 3D-Visualisierung eignet sich besonders gut, einen Überblick über die Verhältnisse zwischen den drei Metriken zu erhalten: (die Werte wurden hier bereits normalisiert, liegen also zwischen 0,00 und 1,00)

fig = pyplot.figure()

ax = fig.add_subplot(111, projection='3d')

ax.scatter(dataSet[:,0], dataSet[:,2], dataSet[:,1], marker='o', color=classColorVector)

ax.set_xlabel("Raumflaeche in Quadratmeter")

ax.set_ylabel("IA_Ratio")

ax.set_zlabel("Wandhoehe in Meter")

ax.set_xlim(xmin=0)

ax.set_ylim(ymin=0)

ax.set_zlim(zmin=0)

pyplot.show()

Es zeigt sich gerade in der 3D-Ansicht recht deutlich, dass sich Büros und Wohnungen zum nicht unwesentlichen Teil überschneiden und hier jeder Algorithmus mit der Klassifikation in Probleme geraten wird, wenn uns wirklich nur diese drei Dimensionen zur Verfügung stehen.

Schritt 3 – Kalkulation der Distanzen zwischen den einzelnen Punkten

Bei der Berechnung der Distanz in einem Raum hilft uns der Satz des Pythagoras weiter. Die zu überbrückende Distanz, um von A nach B zu gelangen, lässt sich einfach berechnen, wenn man entlang der Raumdimensionen Katheten aufspannt.

$c = \sqrt{a^2+ b^2}$

Die Hypotenuse im Raum stellt die Distanz dar und berechnet sich aus der Wurzel aus der Summe der beiden Katheten im Quadrat. Die beiden Katheten bilden sich aus der Differenz der Punktwerte (q, p) in ihrer jeweiligen Dimension.Bei mehreren Dimensionen gilt der Satz entsprechend:

$Distanz = \sqrt{(q_1-p_1)^2+(q_2-p_2)^2+…+(q_n-p_n)^2}$

Um mit den unterschiedlichen Werte besser in ihrer Relation zu sehen, sollten sie einer Normalisierung unterzogen werden. Dabei werden alle Werte einer Dimension einem Bereich zwischen 0.00 und 1.00 zugeordnet, wobei 0.00 stets das Minimum und 1.00 das Maximum darstellt.

$NormWert = \frac{Wert - Min}{Wertspanne} = \frac{Wert - Min}{Max - Min}$

def normalizeDataSet(dataSet):

dataSet_n = numpy.zeros(numpy.shape(dataSet)) #[[ 0. 0. 0.]

# [ 0. 0. 0.]

# ...,

# [ 0. 0. 0.]

# [ 0. 0. 0.]]

minValues = dataSet.min(0) # [ 10. 2.6 0.]

ranges = dataSet.max(0) - dataSet.min(0) # [ 1775. 2.4 68.]

minValues = dataSet.min(0) # [ 10. 2.6 0.]

maxValues = dataSet.max(0) # [ 1785. 5. 68.]

ranges = maxValues - minValues # [ 1775. 2.4 68.]

rowCount = dataSet.shape[0] # 1039

# numpy.tile() wiederholt Sequenzen (hier: [[ 10. 2.6 0. ], ..., [ 10. 2.6 0. ]]

dataSet_n = dataSet - numpy.tile(minValues, (rowCount, 1)) #[[ 2.56000000e+02 9.00000000e-01 1.80000000e+01]

# [ 6.60000000e+01 2.00000000e-01 5.40000000e+01]

# [ 3.32000000e+02 1.50000000e-01 1.00000000e+01]

# ...,

# [ 1.58000000e+02 6.00000000e-01 0.00000000e+00]

# [ 5.70000000e+01 1.00000000e-01 5.20000000e+01]

# [ 1.68000000e+02 2.00000000e-01 0.00000000e+00]]

dataSet_n = dataSet_n / numpy.tile(ranges, (rowCount, 1)) #[[ 0.14422535 0.375 0.26470588]

# [ 0.0371831 0.08333333 0.79411765]

# [ 0.18704225 0.0625 0.14705882]

# ...,

# [ 0.08901408 0.25 0.]

# [ 0.03211268 0.04166667 0.76470588]

# [ 0.09464789 0.08333333 0.]]

#print(dataSet_n)

return dataSet_n, ranges, minValues

Die Funktion kann folgendermaßen aufgerufen werden:

1 2	dataSet_n, ranges, minValues = normalizeDataSet(dataSet)

Schritt 4 & 5 – Klassifikation durch Eingrenzung auf k-nächste Nachbarn

Die Klassifikation erfolgt durch die Kalkulation entsprechend der zuvor beschriebenen Formel für die Distanzen in einem mehrdimensionalen Raum, durch Eingrenzung über die Anzahl an k Nachbarn und Sortierung über die berechneten Distanzen.

def classify(inX, dataSet, labels, k):

rowCount = dataSet.shape[0] # Anzahl an Zeilen bestimmen

diffMat = numpy.tile(inX, (rowCount,1)) - dataSet # Berechnung der Katheten

# (über tile() wird der Eingangsdatensatz über die Zeilenanzahl des dataSet vervielfacht,

# der dataSet davon substrahiert)

sqDiffMat = diffMat**2 # Quadrat der Katheten

sqDistances = sqDiffMat.sum(axis=1) # Aufsummieren der Differenzpaare

distances = sqDistances**0.5 # Quadratwurzel über alle Werte

sortedDistIndicies = distances.argsort() # Aufsteigende Sortierung

classCount = {}

#print("inX = %s, k = %s" % (inX, k))

#print(sortedDistIndicies)

for i in range(k): # Eingrenzung auf k-Werte in der sortierten Liste

closest = labels[sortedDistIndicies[i]] # Label (Kategorie [Büro, Wohnung, Haus] entsprechend der Sortierung aufnehmen

classCount[closest] = classCount.get(closest, 0) + 1 # Aufbau eines Dictionary über die

sortedClassCount = sorted(classCount, key = classCount.get, reverse=True) # Absteigende Sortierung der gesammelten Labels in k-Reichweite

# wobei die Sortierung über den Count (Value) erfolgt

#print(classCount)

#print(sortedClassCount[0])

return sortedClassCount[0] # Liefere das erste Label zurück

# also das Label mit der höchsten Anzahl innerhalb der k-Reichweite

Über folgenden Code rufen wir die Klassifikations-Funktion auf und legen die k-Eingrenzung fest, nebenbei werden Fehler gezählt und ausgewertet. Hier werden der Reihe nach die ersten 30 Zeilen verarbeitet:

errorCount = 0

k = 5 # k-Eingrenzung (hier: auf 5 Nachbarn einschränken)

rowCount = dataSet_n.shape[0] # Anzahl der Zeilen im gesamten Datensatz

numTestVectors = 30 # Datensätze 0 - 29 werden zum testen von k verwendet,

# die Datensätze ab Zeile 30 werden zur Klassifikation verwendet

for i in range(0, numTestVectors): # Aufruf des Klassifikators von 0 bis 29

result = classify(dataSet_n[i,:], dataSet_n[numTestVectors:rowCount,:], classLabelVector[numTestVectors:rowCount], k)

print("%s - the classifier came back with: %s, the real answer is: %s" %(i, result, classLabelVector[i]))

if (result != classLabelVector[i]):

errorCount += 1.0

print("Error Count: %d" % errorCount)

Nur 30 Testdatensätze auszuwählen ist eigentlich viel zu knapp bemessen und hier nur der Übersichtlichkeit geschuldet. Besser ist für dieses Beispiel die Auswahl von 100 bis 300 Datensätzen. Die Ergebnisse sind aber bereits recht ordentlich, allerdings fällt dem Algorithmus – wie erwartet – noch die Unterscheidung zwischen Wohnungen und Büros recht schwer.

0 – klassifiziert wurde: Buero, richtige Antwort: Buero
1 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
2 – klassifiziert wurde: Buero, richtige Antwort: Buero
3 – klassifiziert wurde: Buero, richtige Antwort: Buero
4 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
5 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
6 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
7 – klassifiziert wurde: Wohnung, richtige Antwort: Buero
8 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
9 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
10 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
11 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
12 – klassifiziert wurde: Buero, richtige Antwort: Buero
13 – klassifiziert wurde: Wohnung, richtige Antwort: Buero
14 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
15 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
16 – klassifiziert wurde: Buero, richtige Antwort: Buero
17 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
18 – klassifiziert wurde: Haus, richtige Antwort: Haus
19 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
20 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
21 – klassifiziert wurde: Buero, richtige Antwort: Buero
22 – klassifiziert wurde: Buero, richtige Antwort: Buero
23 – klassifiziert wurde: Buero, richtige Antwort: Buero
24 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
25 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
26 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
27 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
28 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
29 – klassifiziert wurde: Buero, richtige Antwort: Buero
Error Count: 2

Über weitere Tests wird deutlich, dass k nicht zu niedrig und auch nicht zu hoch gesetzt werden darf.

Datensätze	k	Fehler
150	1	25
150	3	23
150	5	21
150	20	26

Ein nächster Schritt wäre die Entwicklung eines Trainingprogramms, dass die optimale Konfiguration (k-Eingrenzung, Gewichtung usw.) ermittelt.

Fehlerraten herabsenken

Die Fehlerquote ist im Grunde niemals ganz auf Null herabsenkbar, sonst haben wir kein maschinelles Lernen mehr, sondern könnten auch feste Regeln ausmachen, die wir nur noch einprogrammieren (hard-coding) müssten. Wer lernt, macht auch Fehler! Dennoch ist eine Fehlerquote von 10% einfach zu viel für die meisten Anwendungsfälle. Was kann man hier tun?

Den Algorithmus verbessern (z. B. optimale k-Konfiguration und Gewichtung finden)
mehr Merkmale finden (= mehr Dimensionen)
mehr Daten hinzuziehen (gut möglich, dass alleine dadurch z. B. Wohnungen und Büros besser unterscheidbar werden)
einen anderen Algorithmus probieren (kNN ist längst nicht für alle Anwendungen ideal!)

Das Problem mit den Dimensionen

Theoretisch kann kNN mit undenklich vielen Dimensionen arbeiten, allerdings steigt der Rechenaufwand damit auch ins unermessliche. Der k-nächste-Nachbar-Algorithmus ist auf viele Daten und Dimensionen angewendet recht rechenintensiv.

In der Praxis hat nicht jedes Merkmal die gleiche Tragweite in ihrer Bedeutung für die Klassifikation und mit jeder weiteren Dimension steigt auch die Fehleranfälligkeit, insbesondere durch Datenfehler (Rauschen). Dies kann man sich bei wenigen Dimensionen noch leicht bildlich vorstellen, denn beispielsweise könnten zwei Punkte in zwei Dimensionen nahe beieinander liegen, in der dritten Dimension jedoch weit auseinander, was im Ergebnis dann eine lange Distanz verursacht. Wenn wir beispielsweise 101 Dimensionen berücksichtigen, könnten auch hier zwei Punkte in 100 Dimensionen eng beieinander liegen, läge jedoch in der 101. Dimension (vielleicht auch auf Grund eines Datenfehlers) eine lange Distanz vor, wäre die Gesamtdistanz groß. Mit Gewichtungen könnten jedoch als wichtiger einzustufenden Dimensionen bevorzugt werden und als unsicher geltende Dimensionen entsprechend entschärft werden.

Je mehr Dimensionen berücksichtigt werden sollen, desto mehr Raum steht zur Verfügung, so dass um wenige Datenpunkte viel Leerraum existiert, der dem Algorithmus nicht weiterhilft. Je mehr Dimensionen berücksichtigt werden, desto mehr Daten müssen zu Verfügung gestellt werden, im exponentiellen Anstieg – Wo wir wieder beim Thema Rechenleistung sind, die ebenfalls exponentiell ansteigen muss.

Weiterführende Literatur

Machine Learning in Action

Introduction to Machine Learning with Python

Einführung in Data Science: Grundprinzipien der Datenanalyse mit Python

KNN: Rückwärtspass

April 12, 2016/0 Comments/in Artificial Intelligence, Big Data, Data Mining, Data Science, Data Science Hack, Machine Learning, Mathematics, Octave, Tutorial /by Nico Hezel

Im letzten Artikel der Serie haben wir gesehen wie bereits trainierte Netzwerke verwendet werden können. Als Training wird der Prozess bezeichnet der die Gewichte in einen Netzwerk so anpasst, dass bei einem Vorwärtspass durch ein Netzwerk zu einen festgelegten Eingangsdatensatz ein bestimmtes Ergebnis in der Ausgangsschicht ausgegeben wird. Im Umkehrschluss heißt das auch, dass wenn etwas anderes ausgeliefert wurde als erwartet, das Netzwerk entweder noch nicht gut genug oder aber auf ein anderes Problem hin trainiert wurde.

Training

Das Training selbst findet in drei Schritten statt. Zunächst werden die Gewichte initialisiert. Üblicherweise geschieht das mit zufälligen Werten, die aus einer Normalverteilung gezogen werden. Je nachdem wie viele Gewichte eine Schicht hat, ist es sinnvoll die Verteilung über den Sigma Term zu skalieren. Als Daumenregeln kann dabei eins durch die Anzahl der Gewichte in einer Schicht verwendet werden.

Im zweiten Schritt wird der Vorwärtspass für die Trainingsdaten errechnet. Das Ergebnis wird beim ersten Durchlauf alles andere als zufrieden stellend sein, es dient aber dem Rückwärtspass als Basis für dessen Berechnungen und Gewichtsänderungen. Außerdem kann der Fehler zwischen der aktuellen Vorhersage und dem gewünschten Ergebnis ermittelt werden, um zu entscheiden, ob weiter trainiert werden soll.

Der eigentliche Rückwärtspass errechnet aus der Differenz der Vorwärtspassdaten und der Zieldaten die Steigung für jedes Gewicht aus, in dessen Richtung dieses geändert werden muss, damit das Netzwerk bessere Vorhersagen trifft. Das klingt zunächst recht abstrakt, die genauere Mathematik dahinter werde ich in einem eigenen Artikel erläutern. Zur besseren Vorstellung betrachten wir die folgende Abbildung.

visuelle Darstellung aller Gewichtskombinationen und deren Vorhersagefehler

Das Diagramm zeigt in blau zu allen möglichen Gewichtskombinationen eines bestimmten, uns unbekannten, Netzwerks und Problems den entsprechenden Vorhersagefehler. Die Anzahl der Kombinationen hängt von der Anzahl der Gewichte und der Auflösung des Wertebereiches für diese ab. Theoretisch ist die Menge also unendlich, weshalb die blaue Kurve eine von mir ausgedachte Darstellung aller Kombinationen ist. Der erste Vorwärtspass liefert uns eine Vorhersage die eine normalisierte Differenz von 0.6 zu unserem eigentlichen Wunschergebnis aufweist. Visualisiert ist das Ganze mit einer schwarzen Raute. Der Rückwärtspass berechnet aus der Differenz und den Daten vom Vorwärtspass einen Änderungswunsch für jedes Gewicht aus. Da die Änderungen unabhängig von den anderen Gewichten ermittelt wurden, ist nicht bekannt was passieren würde wenn alle Gewichte sich auf einmal ändern würden. Aus diesem Grund werden die Änderungswünsche mit einer Lernrate abgeschwächt. Im Endeffekt ändert sich jedes Gewicht ein wenig in die Richtung, die es für richtig erachtet. In der Hoffnung einer Steigerung entlang zu einem lokalen Minimum zu folgen, werden die letzten beiden Schritte (Vor- und Rückwärtspass) mehrfach wiederholt. In dem obigen Diagramm würde die schwarze Raute der roten Steigung folgen und sich bei jeder Iteration langsam auf das linke lokale Minimum hinzubewegen.

Anwendungsbeispiel und Programmcode

Um den ganzen Trainingsprozess im Einsatz zu sehen, verwenden wir das Beispiel aus dem Artikel “KNN: Vorwärtspass”. Die verwendeten Daten kommen aus der Wahrheitstabelle eines X-OR Logikgatters und werden in ein 2-schichtiges Feedforward Netzwerk gespeist.

XOR Wahrheitstabelle

X1	X2	Y = X1 ⊻ X2
0	0	0
0	1	1
1	0	1
1	1	0

Der Programmcode ist in Octave geschrieben und kann zu Testzwecken auf der Webseite von Tutorialpoint ausgeführt werden. Die erste Hälfte von dem Algorithmus kennen wir bereits, der Vollständigkeit halber poste ich ihn noch einmal, zusammen mit den Rückwärtspass. Hinzugekommen sind außerdem ein paar Konsolenausgaben, eine Lernrate- und eine Iterations-Variable die angibt wie viele Trainingswiederholungen durchlaufen werden sollen.

%--------------------- Daten -----------------------

X = [0 0; % Eingangsdaten

0 1;

1 0;

1 1]

Y = [0;1;1;0] % erwartete XOR Ausgangsdaten

theta1 = normrnd(0, 1/(3*2), 3, 2); % 3x2 Gewichtsmatrix

theta2 = normrnd(0, 1/(3*1), 3, 1); % 3x1 Gewichtsmatrix

m = length(X) % Anzahl der Eingangsdaten

iteration = 10000 % Anzahl der Trainingsiterationen

alpha = 0.8 % lernrate

printf("\n\nStarte Training ... ")

for(i = 1:iteration)

%--------------------- Vorwärtspass -----------------------

V = X; % anlegen der Eingangsdaten an die Eingangsschicht

% 1. berechne die Aktivierungen der verborgenen Schicht

Vb = [ones(m,1) V]; % hinzufügen der Bias Units (sind immer 1)

Zv = Vb * theta1; % Summe aus den Eingangswerten multipliziert mit deren Gewichten

H = 1 ./ (1 .+ e.^-Zv); % anwenden der Sigmoid Funktion auf die Aktivierungsstärke Zv

% 2. berechne die Aktivierungen der Ausgangsschicht

Hb = [ones(m,1) H]; % hinzufügen der Bias Units an die verborgene Schicht

Zh = Hb * theta2; % Produkt aus den Aktivierungen der Neuronen in H und Theta2

O = 1 ./ (1 .+ e.^-Zh); % Vorhersage von dem Netzwerk

% 3. berechne die Vorhersageungenauigkeit

loss = (O .- Y) .^ 2; % quadratischer Fehler von der Vorhersage und der Zielvorgabe Y

mse = sum(loss) / m; % durchschnittlicher quadratischer Fehler aller Vorhersagen

%--------------------- Rückwärtspass -----------------------

% 1. Ableitung der Fehlerfunktion

d = O .- Y; % Differenzmatrix zwischen der Vorhersage und der Zielvorgabe Y

% 2. berechne die Änderungen für Theta2 und die Ableitung der Ausgangsschicht

OMO = ones(size(O)) .- O; % Zwischenvariable: 1-Minus-Vorhersage

Zhd = d .* O .* OMO; % Ableitung der Sigmoid Funktion

theta2c = Hb' * Zhd; % Änderunswunsch für Theta2

Hd = Zhd * theta2'; % Ableitung von der Ausgangsschicht

Hd(:,[1]) = []; % Ableitung von der Bias Unit

% 3. berechne die Änderungen für Theta1 und die Ableitung der verborgenen Schicht

HMO = ones(size(H)) .- H; % Zweischenvariable: 1 Minus Aktivierung der verborgenen Schicht

Zvd = Hd .* H .* HMO; % Ableitung der Sigmoid Funktion von der Aktivierungsstärke Zv

theta1c = Vb' * Zvd; % Änderunswunsch für Theta1

% weitere Ableitungen sind nicht notwendig

theta1 -= theta1c .* alpha; % ändere die Gewichte von Theta1 und Theta2

theta2 -= theta2c .* alpha; % der Änderungswunsch wird von der Lernrate abgeschwächt

endfor

% Ausgabe von der letzten Vorhersage und den Gewichten

printf("abgeschlossen. \n")

printf("Letzte Vorhersage und trainierte Gewichte\n")

theta1

theta2

Zu jeder Zeile bzw. Funktion die wir im Vorwärtspass geschrieben haben, gibt es im Rückwärtspass eine abgeleitete Variante. Dank den Ableitungen können wir die Änderungswünsche der Gewichte in jeder Schicht ausrechnen und am Ende einer Trainingsiteration anwenden. Wir trainieren 10.000 Iterationen lang und verwenden eine Lernrate von 0,8. In komplexeren Fragestellungen, mit mehr Daten, würden diese Werte niedriger ausfallen.

Es ist außerdem möglich den ganzen Programmcode viel modularer aufzubauen. Dazu werde ich im nächsten Artikel auf eine mehr objekt-orientiertere Sprache wechseln. Nichts desto trotz liefert der obige Algorithmus gute Ergebnisse. Hier ist mal ein Ausgabebeispiel:

X =

0 0

0 1

1 0

1 1

Y =

theta1 =

0.114950 0.046125

0.064683 0.139159

-0.164288 -0.094688

theta2 =

0.33607

-0.31128

0.13993

m = 4

iteration = 10000

alpha = 0.80000

Starte Training ... abgeschlossen.

Letzte Vorhersage und trainierte Gewichte

O =

0.014644

0.983308

0.986137

0.013060

theta1 =

3.2162 -3.0431

6.4365 5.6498

-6.3383 -5.8602

theta2 =

4.4759

-9.5057

9.9795

Neural Nets: Time Series Prediction

February 6, 2016/0 Comments/in Artificial Intelligence, Big Data, Data Science, Data Science Hack, Machine Learning, Main Category, Mathematics, Predictive Analytics, Scala, Tutorial /by Felix Bogdanski

Artificial neural networks are very strong universal approximators. Google recently defeated the worlds strongest Go (“chinese chess”) player with two neural nets, which captured the game board as a picture. Aside from these classification tasks, neural nets can be used to predict future values, behaviors or patterns solely based on learned history. In the machine learning literature, this is often referred to as time series prediction, because, you know, values over time need to be predicted. Hah! To illustrate the concept, we will train a neural net to learn the shape of a sinusoidal wave, so it can continue to draw the shape without any help. We will do this with Scala. Scala is a great lang, because it is strongly typed but feels easy like Python. Throughout this article, I will use the library NeuroFlow, which is a simple, lightweight library I wrote to build and train nets. Because Open Source is the way to go, feel free to check (and contribute to? :-)) the code on GitHub.

Introduction of the shape

If we, as humans, want to predict the future based on historic observations, we would have no other chance but to be guided by the shape drawn so far. Let’s study the plot below, asking ourselves: How would a human continue the plot?

f(x) = sin(10*x)

Intuitively, we would keep on oscillating up and down, just like the grey dotted line tries to rough out. To us, the continuation of the shape is reasonably easy to understand, but a machine does not have a gut feeling to ask for a good guess. However, we can summon a Frankenstein, which will be able to learn and continue the shape based on numbers. In order to do so, let’s have a look at the raw, discrete data of our sinusoidal wave:

x	f(x)
0.0	0.0
0.05	0.479425538604203
0.10	0.8414709848078965
0.15	0.9974949866040544
0.20	0.9092974268256817
0.25	0.5984721441039564
0.30	0.1411200080598672
0.35	-0.35078322768961984
…	…
0.75	0.9379999767747389

Ranging from 0.0 until 0.75, these discrete values drawn from our function with step size 0.05 will be the basis for training. Now, one could come up with the idea to just memorize all values, so a sufficiently reasonable value can be picked based on comparison. For instance, to continue at the point 0.75 in our plot, we could simply examine the area close to 0.15, noticing a similar value close to 1, and hence go downwards. Well, of course this is cheating, but if a good cheat is a superior solution, why not cheat? Being hackers, we wouldn’t care. What’s really limiting here is the fact that the whole data set needs to be kept in memory, which can be infeasible for large sets, plus for more complex shapes, this approach would quickly result in a lot of weird rules and exceptions to be made in order to find comprehensible predictions.

Net to the rescue

Let’s go back to our table and see if a neural net can learn the shape, instead of simply memorizing it. Here, we want our net architecture to be of kind [3, 5, 3, 1]. Three input neurons, two hidden layers with five and three neurons respectively, as well as one neuron for the output layer will capture the data shown in the table.

A supervised training mode means, that we want to train our net with three discrete steps as input and the fourth step as the supervised training element. So we will train a, b, c -> d and e, f, g -> h et cetera, hoping that this way our net will capture the slope pattern of our sinusoidal wave. Let’s code this in Scala:

import neuroflow.core.Activator.Tanh

import neuroflow.core.WeightProvider.randomWeights

import neuroflow.nets.DynamicNetwork.constructor

First, we want a Tanh activation function, because the domain of our sinusoidal wave is [-1, 1], just like the hyperbolic tangent. This way we can be sure that we are not comparing apples with oranges. Further, we want a dynamic network (adaptive learning rate) and random initial weights. Let’s put this down:

val fn = Tanh.apply

val sets = Settings(true, 10.0, 0.0000001, 500, None, None, Some(Map("τ" -> 0.25, "c" -> 0.25)))

val net = Network(Input(3) :: Hidden(5, fn) :: Hidden(3, fn) :: Output(1, fn) :: Nil, sets)

No surprises here. After some experiments, we can pick values for the settings instance, which will promise good convergence during training. Now, let’s prepare our discrete steps drawn from the sinus function:

val group = 4

val sinusoidal = Range.Double(0.0, 0.8, 0.05).grouped(group).toList.map(i => i.map(k => (k, Math.sin(10 * k))))

val xsys = sinusoidal.map(s => (s.dropRight(1).map(_._2), s.takeRight(1).map(_._2)))

val xs = xsys.map(_._1)

val ys = xsys.map(_._2)

net.train(xs, ys)

We will draw samples from the range with step size 0.05. After this, we will construct our training values xs as well as our supervised output values ys. Here, a group consists of 4 steps, with 3 steps as input and the last step as the supervised value.

[INFO] [25.01.2016 14:07:51:677] [run-main-5] Taking step 499 - error: 1.4395661497489177E-4 , error per sample: 3.598915374372294E-5

[INFO] [25.01.2016 14:07:51:681] [run-main-5] Took 500 iterations of 500 with error 1.4304189739640242E-4

[success] Total time: 4 s, completed 25.01.2016 14:20:56

After a pretty short time, we will see good news. Now, how can we check if our net can successfully predict the sinusoidal wave? We can’t simply call our net like a sinus function to map from one input value to one output value, e. g. something like net(0.75) == sin(0.75). Our net does not care about any x values, because it was trained purely based on the function values f(x), or the slope pattern in general. We need to feed our net with a three-dimensional input vector holding the first three, original function values to predict the fourth step, then drop the first original step and append the recently predicted step to predict the fifth step, et cetera. In other words, we need to traverse the net. Let’s code this:

val initial = Range.Double(0.0, 0.15, 0.05).zipWithIndex.map(p => (p._1, xs.head(p._2)))

val result = predict(net, xs.head, 0.15, initial)

result.foreach(r => println(s"${r._1}, ${r._2}"))

with

@tailrec def predict(net: Network, last: Seq[Double], i: Double, results: Seq[(Double, Double)]): Seq[(Double, Double)] = {

if (i < 4.0) {

val score = net.evaluate(last).head

predict(net, last.drop(1) :+ score, i + 0.05, results :+ (i, score))

} else results

}

So, basically we don’t just continue to draw the sinusoidal shape at the point 0.75, we draw the entire shape right from the start until 4.0 – solely based on our trained net! Now, let’s see how our Frankenstein will complete the sinusoidal shape from 0.75 on:

I’d say, pretty neat? Keep in mind, here, the discrete predictions are connected through splines. Another interesting property of our trained net is its prediction compared to the original sinus function when taking the limit towards 4.0. Let’s plot both:

The purple line is the original sinusoidal wave, whereas the green line is the prediction of our net. The first steps show great consistency, but slowly the curves diverge a little over time, as uncertainties will add up. To keep this divergence rather low, one could fine tune settings, for instance numeric precision. However, if one is taking the limit towards infinity, a perfect fit is illusory.

Final thoughts

That’s it! We have trained our net to learn and continue the sinusoidal shape. Now, I know that this is a rather academic example, but to train a neural net to learn more complex shapes is straightforward from here.

Thanks for reading!

Wie lernen Maschinen?

January 20, 2016/0 Comments/in Artificial Intelligence, Big Data, Data Science, Data Science Hack, Machine Learning, Mathematics, R Statistics, Statistics /by Dr. Stefan Kühn

Im dritten Teil meiner Reihe Wie lernen Maschinen? wollen wir die bisher kennengelernten Methoden anhand eines der bekanntesten Verfahren des Maschinellen Lernens – der Linearen Regression – einmal gegenüberstellen. Die Lineare Regression dient uns hier als Prototyp eines Verfahrens aus dem Gebiet der Regression, in weiteren Artikeln werden die Logistische Regression als Prototyp eines Verfahrens aus dem Gebiet der Klassifikation und eine Collaborative-Filtering- bzw. Matrix-Faktorisierungs-Methode als Prototyp eines Recommender-Systems behandelt.

Wahrscheinlichkeitesrechnung – Grundstein für Predictive Analytics

November 11, 2015/6 Comments/in Data Science, Mathematics, Predictive Analytics, Statistics /by Benjamin Aunkofer

Die Wahrscheinlichkeitsrechnung behandelt die Gesetzmäßigkeiten des (von außen betrachtet) zufälligen Vorkommens bestimmter Ereignisse aus einer vorgegebenen Ereignismenge. Die mathematische Statistik fasst diese Wahrscheinlichkeitsrechnung zur Stochastik zusammen, der Mathematik des Zufalls.

Mit diesem Artikel – zu der ich eine Serie plane – möchte ich den Einstieg in Predictive Analytics wagen, zugegebenermaßen ein Themengebiet, in dem man sich sehr schnell verlieren und den Wald vor lauter Bäumen nicht mehr findet. Also belassen wir es erstmal bei einem sanften Einstieg…

Klassische Definition der Wahrscheinlichkeit

Das klassische Verständnis der Wahrscheinlichkeit geht von endlich vielen Ausgängen (Ereignisse) aus, bei denen alle Ausgänge gleich wahrscheinlich sind. Die dafür erdachten Zufallsexperimente wurden von dem französischen Mathematiker Pierre Simon Lapplace (1749 – 1827) zum ersten Mal nachvollziehbar beschrieben. Diese Zufallsexperimente werden daher auch Laplace-Experimente genannt.

Bei einem Laplace Experiment gilt:

Ereignismenge $\Omega = {\omega_1,\omega_2,\omega_3,…\omega_s}$
Wahrscheinlichkeit $p(w_j)=\frac{1}{s}=\frac{1}{|\Omega|}$
$(j=1,2,3,…s)$

Die Ergebnismenge, das ist die Menge aller möglichen Ereignisse, wird in der Regel mit einem $\Omega$ (Omega) gekennzeichnet, ein beliebiges Einzelereignis hingegen als $\omega$ (kleines Omega).

Eine typische Laplace-Wahrscheinlichkeitsfrage ist ein bevorstehender Würfelwurf. Wie groß ist die Wahrscheinlichkeit, mit einem echten (unverfälschten) Würfel eine gerade Zahl zu würfeln?

Mit $\Omega={1,2,3,4,5,6}$ und $A={2,4,6}$ folgt $P(A)=\frac{|A|}{|\Omega|}=\frac{3}{6}=0,5$ .

Axiomatische Definition der Wahrscheinlichkeit

Jeder Wahrscheinlichkeitsbegriff muss auf denselben äußeren Bedingungen beruhenden Zufallsexperimenten beliebig oft wiederholbar sein. Die axiomatische Definition der Wahrscheinlichkeit P(A) eines Ereignisses A berücksichtigt Axiome. Axiome sind nicht beweisbare Grundpostulate, darunter fallen Gegebenheiten, die gewissermaßen unverstanden sind und deren Vorkommen und Bedeutung in der Regel empirisch belegt werden müssen.
Die Definition der axiomatischen Wahrscheinlichkeit stammt vom russischen Mathematiker Andrej Nikollajewitsch Kolmogorov (1903 – 1987).

In der Realität gibt es keine perfekte Zufälligkeit, denn jedes Ergebnis ist von ganz bestimmten Faktoren abhängig. Auf den Würfelwurf bezogen, hängt das gewürfelte Ergebnis von unüberschaubar vielen Faktoren ab. Wären diese alle bekannt, könnte das Ergebnis exakt berechnet und somit mit einer Sicherheit vorhergesagt werden. Da dafür jedoch in der Praxis unbestimmbar viele Faktoren eine Rolle spielen (beispielsweise die genaue Beschaffenheit des Würfels in Form, Gewicht, Materialwiderstand, der genaue Winkel, die Fallgeschwindigkeit, die Ausgangsposition der Hand und des Würfels) können wir das Ergebnis nur schätzen, indem die Beschreibung des Vorgangs vereinfacht wird. Nur diese Vereinfachung macht es uns möglich, Vorhersagen zu treffen, die dann jedoch nur eine Wahrscheinlichkeit darstellen und somit mit einer Unsicherheit verbunden sind.

In der abstrakten Welt des perfekten Zufalls gäbe es die gleiche Chance, eine “4” zu würfeln, wie jeweils alle anderen Ziffern.

Mit $\Omega={1,2,3,4,5,6}$ und $A={4}$ folgt $P(A)=\frac{|A|}{|\Omega|}=\frac{1}{6}=0,167$ .

Das Ergebnis eines Wurfes des Würfels ist in der Realität auch von der Beschaffenheit des Würfels abhängig. Angenommen, der Würfel hat auf Seite der Ziffer “4” bei allen vier Kanten eine Abrundung, die ein Umkippen auf eine andere Seite begünstigen, so bedeutet dies:

Die Ziffer “4” hat vier abgerundete Kanten, die Wahrscheinlichkeit eine “4” zu würfeln sinkt stark
Die Ziffern “1”, “3”, “5”, “6” haben jeweils eine abgerundete Kante (Berühungskante zur “4”) sinkt
Die Ziffer “2” liegt der “4” gegenüber, hat somit keine Berührungskante und keine Abrundung, so steigt ihre Chance gewürfelt zu werden

Nun könnte sich nach einer empirischen Untersuchung mit einer ausreichenden Stichprobe folgende Wahrscheinlichkeit ergeben:

$p(4) = 0,1$
$p(1) = p(3) = p(5) = p(6) = 0,15$
$p(2) = 0,3$
$P(\Omega) = 1,0$

Durch die Analyse der bisherigen Wurf-Historie und der Betrachtung der Beschaffenheit der Kanten des Würfels können wir uns somit weit realistischere Wahrscheinlichkeiten über die Wurfergebnisse ermitteln. Wie hoch wäre nun die Wahrscheinlichkeit, nach einem Wurf eine gerade Zahl zu würfeln?

Mit $\Omega={1,2,3,4,5,6}$ und $A={2,4,6}$ folgt $P(A)=p(2)+p(4)+p(6)=0,55$ .

1 Introduction

2 Data Cleaning and Data Processing Methodology

2.1 Determining VTEC: Thin Shell Mapping Function

2.2 Phase Smoothing

2.3 Residual Determination

3 Results

3.1 Tohoku Earthquake

3.2 South Georgia Earthquake

4 Conclusion

Regression – Die Vorhersage von stetigen Werten

Klassifikation – Die Vorhersage von Gruppenzugehörigkeiten

Fazit – Unterschied zwischen Klassifikation und Regression

Und Clustering?

Was ist die Warenkorbanalyse?

Datenaufbau

Beschreibende Datenanalyse

Verbundanalyse

Assoziationsregeln

Algorithmen

Umsetzung mit R

Referenzen:

Benford-Algorithmus in Python mit NumPy und Pandas

Analyse der Verteilung der ersten Ziffer in Zahlungsdaten

Abgleich der Ziffernhäufigkeit mit der Erwartung

Gegenüberstellung: Computer-generierte Zufallszahlen

Anwendung in der Praxis

Die Rastrigin-Funktion

Die Rastrigin-Funktion im Standard-Python umsetzen und visualisieren

Die Rastrigin-Funktion mehrdimensional umsetzen, mit NumPy-Matrizen-Funktionen

Klassifikation via K-Nearest Neighbour Algorithmus

Vorab: Verwendete Bibliotheken

Schritt 1 – Daten betrachten und Merkmale erkennen

Schritt 2 – Merkmale im Verhältnis zueinander perspektivisch betrachten

Schritt 3 – Kalkulation der Distanzen zwischen den einzelnen Punkten

Schritt 4 & 5 – Klassifikation durch Eingrenzung auf k-nächste Nachbarn

Fehlerraten herabsenken

Das Problem mit den Dimensionen

Weiterführende Literatur

Training

visuelle Darstellung aller Gewichtskombinationen und deren Vorhersagefehler

Anwendungsbeispiel und Programmcode

Introduction of the shape

Net to the rescue

Final thoughts

Klassische Definition der Wahrscheinlichkeit

Axiomatische Definition der Wahrscheinlichkeit

Interesting links

Pages

Categories

Archive