anomalierkennung und dichteschätzung hinzugefügt

Acronyms.tex

@@ -16,4 +16,6 @@
     \acro{FPC}{(Bocklisch's) Fuzzy Pattern Classifier}
     \acro{MFPC}{Modified-Fuzzy-Pattern-Classifier}
     \acro{FPGA}{Field Programmable Gate Array}
+    \acro{PPV}{Positive Prediction Value}
+    \acro{TPR}{True Positive Rate}
 \end{acronym}

Readme.md

@@ -1,4 +1,26 @@
 # Zusammenfassung Maschinelles Lernen
 Dieses Repo beinhaltet die $\LaTeX$ Informationen für die Zusammenfassung im Fach Maschinelles Lernen.
+
+## TO-DO
+- [x] Qualitätsmaße (https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers)
+  - [x] Nachteile von Accuracy
+  - [x] Fokus auf Accuracy, F1, Precision und Recall 
+- [x] $w_0$ bei Perzeptron erklären (siehe Feedback Übung 3.1)
+- [x] Backpropagation Rechenbeispiel (Übung ML_2020_11_16, KI Zusammenfassung, Feedback Übung 3.2)
+  - [x] Gradientenverfahren aus KI
+  - [x] inkl. mehrere Schichten (Übung 3.3)
+- [x] Begründung für Anzahl von Neuronen in der verdeckten Schicht (ML_2020_11_23)
+  - [x] Beispiele aus ML_2020_11_23 (43:00) miteinbeziehen
+- [x] Perzeptron ist ein Überbegriff (kann aus mehreren Neuronen bestehen)(Besteht aus Input-Gedöns-Output)
+- [x] Regularisierung
+  - ist dafür da Overfitting zu vermeiden
+  - Tikhonov Regularisierung (L2-Norm ($L_2(w)=\sqrt{\sum|w|^2}$)) (ridge regression)
+    $$V(y',y) + \lambda L_2^2(w) = V(y',y) + \lambda\sum|w|^2$$
+  - Early stopping
+  - Lasso Regularisierung (L1-Norm($L_1(w)=\sum|w|$))
+    $$V(y',y) + \lambda L_1(w) = V(y',y) + \lambda \sum|w|$$
+
+- [x] Anomaliedetektion (ML_2020_12_21)
+- [x] Dichteschätzung (ML_2020_12_21)
 ## Hinweise
 Requires you to enable [--shell escape](https://tex.stackexchange.com/questions/516604/how-to-enable-shell-escape-or-write18-visual-studio-code-latex-workshop)

chapters/Semi-supervised Learning/CNN.tex

@@ -0,0 +1,98 @@
+\chapter{\acfp{CNN}}
+\label{cnn}
+    \acp{CNN} enthalten 3 wichtige Bestandteilen:
+    \begin{center}
+        \includegraphics[width=.7\textwidth]{cnn_building_blocks.png}
+    \end{center}
+    Diese Bestandteile können beliebig oft hintereinander geschaltet sein.
+    Zudem ist an ein komplettes \ac{CNN} zumeist noch ein weiteres Netzwerk für die Ausgabe der Vorhersage angeschlossen:
+    \begin{center}
+        \includegraphics[width = .7\textwidth]{cnn_complete.png}
+    \end{center}
+
+    \section{convolutional stage}
+    \label{cnn: convolutional stage}
+        In der \say{convolutional stage} werden \say{convolutional layer} (Faltunsschicht) verwendet.
+        Diese wenden einen beweglichen Filter (detector) auf die Daten der vorhergegangenen Schicht an.
+        Hierbei stellt der detector ein Rezeptives Feld dar (vergleichbar mit dem Auge).\\
+        \includegraphics[width = \textwidth]{convolutional_operation.png}\\
+        \begin{wrapfigure}{r}{.4\textwidth}
+            \includegraphics[width = .4\textwidth]{cnn_inter_layer_connection.png}
+        \end{wrapfigure}
+        Aufgrund der geringen Größe des rezeptiven Feldes ist jedes Neuron in der nachfolgenden Schicht jeweils nur mit wenigen Neuronen in der unterliegenden Schicht verbunden:\\
+        \vspace{30mm}
+
+        \includegraphics[width=\textwidth]{convolutional filter.png}
+\pagebreak
+
+        \subsection{Beispiel}
+        \label{cnn: example}
+            Im folgenden wird das Verfahren des convolutional layers anhand von $3\times 3$ Filtern demononstriert.
+            Diese werden auf einem $6\times 6$ Bild verschoben.
+            Die Filter sollen jeweils unterschiedliche geometrische Formen erkennen (Filter1: Diagonalen)\\
+            \includegraphics[width=.6\textwidth]{cnn_example1.png}\\
+            Über den Parameter \say{stride} kann eingestellt werden, um wieviele Elemente der Filter jeweils verschoben wird:\\
+            \includegraphics[width = .7\textwidth]{cnn_example_stride1.png}\\
+            \includegraphics[width = .7\textwidth]{cnn_example_stride2.png}\\
+            Für jeden Filter entsteht durch diese Anwendung ein kleineres Bild, welches aus dem Ausgangsbild errechnet wurde:\\
+            \includegraphics[width=.8\textwidth]{cnn_feature_map1.png}\\
+            Durch die Anwendung der verschiedenen Filter entsteht hierbei eine mehrdimensionale \say{Feature Map}.
+            Diese wird allgemein als \say{Tensor} bezeichnet:\\
+            \includegraphics[width=.8\textwidth]{cnn_feature_map2.png}\\
+\pagebreak
+
+        \subsection{Convolutional vs. Fully Connected}
+        \label{cnn: convolutional vs. fully connected}
+            Der Vorteil, den der Ansatz der Faltungsschichten gegenüber dem einsatz von \say{fully connected layers} hat ist,
+            dass deutlich weniger Parameter benötigt werden.\\
+            \includegraphics[width = .8\textwidth]{convolutional_vs_fully-connected.png}
+
+    \section{non-linear stage}
+    \label{cnn: non-linear stage}
+        Es ist mathematisch beweisbar, dass für die Abbildung von gleichen Äquivalenzklassen auf eine Referenzklasse eine nicht-linear Funktion benötigt wird.
+        Hierbei gibt es mehrere mögliche Funktionen.
+        Die bekannteste ist hierbei die \say{Sigmoid}-Funktion.
+        Bei \acp{CNN} wird allerdings meistens die \say{ReLU}-Funktion verwendet.\\
+        \includegraphics[width = .9\textwidth]{non-linear_functions.png}
+
+    \section{Pooling}
+    \label{cnn:pooling}
+        Beim \say{Pooling} wird die Menge der Elemente in einer Schicht reduziert.
+        Hierbei wird darauf geachtet, dass nur unwichtige Daten \say{verloren gehen}.
+        Man spricht auch von \say{Subsampling}.\\
+        \includegraphics[width = .8\textwidth]{subsampling.png}
+
+        \subsection{Max Pooling}
+        \label{cnn: max pooling}
+            Das \say{Max Pooling} ist eine Form des Poolings, bei dem mehrere Elemente einer schicht dadurch zusammengefasst werden,
+            dass nur die Element mit dem höchsten Wert erhalten bleiben.\\
+            \includegraphics[width = .8\textwidth]{max_pooling.png}
+
+    \section{Regularisierung}
+    \label{cnn: regularisierung}
+        Um Overfitting zu vermeiden können die Verlustfunktionen (Zusammenfassung KI),
+        mithilfe derer die Gewichte über Backpropagation (\ref{knn: backpropagation}) geupdated werden,
+        regularisiert werden.\\
+        \textbf{Vorsicht:} eine zu starke Regularisierung kann zu einem Underfitting führen,
+        wohingegen eine zu schwache Regularisierung das Overfitting nicht verhindert.
+        Meist lässt sich die \say{Stärke} der Regularisierung durch eine Parameter ($\lambda$) vorgeben.
+
+        \subsection{Lasso Regularisierung}
+        \label{cnn: lasso regularisierung}
+            Die Lasso Regularisierung nutzt die $L_1$-Norm:
+            $$L_1(\bm{w})=\sum_{w_i\in\bm{w}}|w_i|$$
+            Hierdurch ergibt sich für den Wert, mit dem die Gewichte geupdated werden:
+            $$V(y,y')+\lambda\cdot L_1(\bm{w}) = V(y,y') + \lambda\cdot\sum_{w_i\in\bm{w}}|w_i|$$
+        
+        \subsection{Tikhonov Regularisierung}
+        \label{cnn: ridge regression}
+            Die auch als \say{Ridge Regression} bekannte Regularisierung nutzt die $L_2$-Norm:
+            $$L_2(\bm{w})=\sqrt{\sum_{w_i\in\bm{w}}|w_i|^2}$$
+            Hierdurch ergibt sich für den Wert, mit dem die Gewichte geupdated werden:
+            $$V(y,y')+\lambda\cdot L_2^2(\bm{w}) = V(y,y') + \lambda\cdot\sum_{w_i\in\bm{w}}|w_i|^2$$
+
+        \subsection{Early Stopping}
+        \label{cnn: early stopping}
+            Das Verfahren des \say{Early Stopping} kann als eine Regularisierung in der Zeit betrachtet werden.
+            Hierbei wird nach einer bestimmten Anzahl von Epochen das Lernen beendet.
+            Dies kann ebenfalls ein Overfitting verhindern.

chapters/Semi-supervised Learning/Deep Learning.tex

@@ -56,68 +56,6 @@
             \includegraphics[width=\textwidth]{abstract catifier.png}\\
             Ein Beispiel für die einzelnen Features könnte wie folgt aussehen:\\
             \includegraphics[width = \textwidth]{car features.png}
-            
-    \section{\acp{CNN}}
-    \label{cnn}
-        \acp{CNN} enthalten 3 wichtige Bestandteilen:\\
-        \includegraphics[width=.8\textwidth]{cnn_building_blocks.png}\\
-        Diese Bestandteile können beliebig oft hintereinander geschaltet sein.
-        Zudem ist an ein komplettes \ac{CNN} zumeist noch ein weiteres Netzwerk für die Ausgabe der Vorhersage angeschlossen:\\
-        \includegraphics[width = \textwidth]{cnn_complete.png}
-
-        \subsection{convolutional stage}
-        \label{cnn: convolutional stage}
-            In der \say{convolutional stage} werden \say{convolutional layer} (Faltunsschicht) verwendet.
-            Diese wenden einen beweglichen Filter (detector) auf die Daten der vorhergegangenen Schicht an.
-            Hierbei stellt der detector ein Rezeptives Feld dar (vergleichbar mit dem Auge).\\
-            \includegraphics[width = \textwidth]{convolutional_operation.png}\\
-            \begin{wrapfigure}{h}{.4\textwidth}
-                \includegraphics[width = .4\textwidth]{cnn_inter_layer_connection.png}
-            \end{wrapfigure}
-            Aufgrund der geringen Größe des rezeptiven Feldes ist jedes Neuron in der nachfolgenden Schicht jeweils nur mit wenigen Neuronen in der unterliegenden Schicht verbunden:\\
-            \includegraphics[width=\textwidth]{convolutional filter.png}\\
-
-            \subsubsection{Beispiel}
-            \label{cnn: example}
-                Im folgenden wird das Verfahren des convolutional layers anhand von $3\times 3$ Filtern demononstriert.
-                Diese werden auf einem $6\times 6$ Bild verschoben.
-                Die Filter sollen jeweils unterschiedliche geometrische Formen erkennen (Filter1: Diagonalen)\\
-                \includegraphics[width=.8\textwidth]{cnn_example1.png}\\
-                Über den Parameter \say{stride} kann eingestellt werden, um wieviele Elemente der Filter jeweils verschoben wird:\\
-                \includegraphics[width = .8\textwidth]{cnn_example_stride1.png}\\
-                \includegraphics[width = .8\textwidth]{cnn_example_stride2.png}\\
-                Für jeden Filter entsteht durch diese Anwendung ein kleineres Bild, welches aus dem Ausgangsbild errechnet wurde:\\
-                \includegraphics[width=.8\textwidth]{cnn_feature_map1.png}\\
-                Durch die Anwendung der verschiedenen Filter entsteht hierbei eine mehrdimensionale \say{Feature Map}.
-                Diese wird allgemein als \say{Tensor} bezeichnet:\\
-                \includegraphics[width=.8\textwidth]{cnn_feature_map2.png}\\
-
-            \subsubsection{Convolutional vs. Fully Connected}
-            \label{cnn: convolutional vs. fully connected}
-                Der Vorteil, den der Ansatz der Faltungsschichten gegenüber dem einsatz von \say{fully connected layers} hat ist,
-                dass deutlich weniger Parameter benötigt werden.\\
-                \includegraphics[width = .8\textwidth]{convolutional_vs_fully-connected.png}
-
-        \subsection{non-linear stage}
-        \label{cnn: non-linear stage}
-            Es ist mathematisch beweisbar, dass für die Abbildung von gleichen Äquivalenzklassen auf eine Referenzklasse eine nicht-linear Funktion benötigt wird.
-            Hierbei gibt es mehrere mögliche Funktionen.
-            Die bekannteste ist hierbei die \say{Sigmoid}-Funktion.
-            Bei \acp{CNN} wird allerdings meistens die \say{ReLU}-Funktion verwendet.\\
-            \includegraphics[width = \textwidth]{non-linear_functions.png}
-
-        \subsection{Pooling}
-        \label{cnn:pooling}
-            Beim \say{Pooling} wird die Menge der Elemente in einer Schicht reduziert.
-            Hierbei wird darauf geachtet, dass nur unwichtige Daten \say{verloren gehen}.
-            Man spricht auch von \say{Subsampling}.\\
-            \includegraphics[width = .8\textwidth]{subsampling.png}
-
-            \subsubsection{Max Pooling}
-            \label{cnn: max pooling}
-                Das \say{Max Pooling} ist eine Form des Poolings, bei dem mehrere Elemente einer schicht dadurch zusammengefasst werden,
-                dass nur die Element mit dem höchsten Wert erhalten bleiben.\\
-                \includegraphics[width = .8\textwidth]{max_pooling.png}
 
     \section{classsical \ac{ML} vs. Deep Learning}
         \includegraphics[width = \textwidth]{classical_ml_vs_deep_learning.png}

chapters/Supervised Learning/Linear Machines.tex

@@ -45,15 +45,23 @@
 
     \section{Das technische Neuron}
         Ein technisches Neuron besteht aus den Gewichten für die Eingangswerte und der Aktivierungsfunktion:\\
-        \includegraphics[width=.8\textwidth]{technisches_neuron.png}
+        \begin{center}
+            \includegraphics[width=.7\textwidth]{technisches_neuron.png}
+        \end{center}
 
     \section{Das Perzeptron}\label{perceptron}
         Ein Perzeptron beschreibt eine lineare Maschine, die eine Datenmenge durch eine Hyper-Ebene (die Diskriminante) in zwei Cluster unterteilt.
+        Hierbei ist der Begriff \say{Perzeptron} ein Überbegriff für das Konzept.
+        Ein Perzeptron besteht in den meisten fällen nicht nur aus einem einfachen Neuron, sondern oft sogar aus mehreren Schichten von Neuronen.
         Die Funktion für die Diskriminante ist hierbei $y(\bm{m})=\text{sng}(g(\bm{m})) = \text{sgn}(\bm{w}^T\bm{m}+w_0)$.
         Da sich $\bm{w}$ durch $\bm{w} = \sum^n_{i=1}\alpha_i\cdot y_i \cdot \bm{m}_i$ (mit $n = $Anzahl der Datenpunkte und $\alpha_i = $ Anzahl, wie oft $\bm{m}_i$ ausgewählt wurde) definiert ist die Dimension von $\bm{m}$ unwichtig.
+        Das Gewicht $w_0$ wird auch als \say{Bias} bezeichnet wird.
+        Dieses Gewicht ist wichtig, um die Geradengleichung der Diskriminanten aufstellen zu können ($w_0$ verschiebt die Gerade in y Richtung).
+        Ohne das Bias könnte man die Gerade nur drehen und nicht verschieben.
+
         
         \subsection{Beispiel: nicht-symmetrischer Lernalgorithmus}
-            \includegraphics[width=\textwidth]{Perzeptron_Lernalgorithmus.png}
+            \includegraphics[width=.8\textwidth]{Perzeptron_Lernalgorithmus.png}
 
         \subsection{Novikoff's Theorem}\label{novikoffs theorem}
             Novikoff's Theorem besagt, dass der Lernalgorithmus des Perzeptrons bei einem linear trennbaren Datensatz unweigerlich eine Diskriminante findet.
@@ -79,8 +87,15 @@
             \subsection{Das XOR-Problem}
                 Um das XOR-Problem zu zergliedern werden 2 Diskriminanten benötigt:\\
                 \includegraphics[width=\textwidth]{XOR-Problem1.png}\\
-                Um das XOR-Problem von einer linearen Maschine klassifizieren zu lassen muss diese aus mindestens 2 Schichten bestehen.\\
-                \includegraphics[width=\textwidth]{XOR-Problem2.png}
+                Um das XOR-Problem von einer linearen Maschine klassifizieren zu lassen muss diese aus mindestens 2 Schichten bestehen.
+                \begin{center}
+                    \includegraphics[width=.8\textwidth]{XOR-Problem2.png}
+                \end{center}
+                Allgemein werden mehr Neuronen in der verdeckten Schicht gebraucht, je komplexer die Klassifizierung ist.
+                Hierbei kann sich grob an der Anzahl an geraden orientiert werden, die benötigt werden, um die Cluster sauber zu trennen.
+                Dies gibt allerdings nur eine Angabe für die minimale Anzahl an benötigten Neuronen in der verdeckten Schicht.
+                Die genaue Anzahl der verdeckten Schichten und der darin enthaltenen Neuronen müssen vom Entwickler gewählt werden.
+                Hierbei ist die Erfahrung des Entwicklers entscheidend, um ein möglich gutes Modell zu erstellen.
 
     \section{Maximum Margin Approaches}
         Aus \ref{novikoffs theorem} ist bekannt, dass eine Diskriminate erstellt werden kann.
@@ -154,4 +169,76 @@
                 Eine Reduzierung kann entweder dadurch erreicht werden,
                 dass das empirische Risiko (\ref{empirical risk}) bei gleichbleibenden $\varepsilon$ (\ref{capacity term}) reduziert wird,
                 oder durch eine Reduzierung von $\varepsilon$ bei gleichbleibenden empirischen Risiko.
-                Letzteres ist der Ansatz den die \ac{SVM}s (\ref{svm}) verfolgen.
+                Letzteres ist der Ansatz den die \ac{SVM}s (\ref{svm}) verfolgen.
+
+    \section{Parameteroptimierung}
+    \label{knn: parameteroptimierung}
+        Die Parameter werden iterativ so verändert/ optimiert, dass die Fehlerfunktion (Zusammenfassung KI: Fehlerfunktionen) minimal wird.
+
+        \subsection{Gradientenabstieg}
+        \label{knn: gradientenabstieg}
+            Das Gradientenverfahren ist ein Verfahren zur Parameteroptimierung.
+            Die Idee für das Verfahren leitet sich vom Hill-Climbing Algorithmus (Zusammenfassung KI: Hill Climbing) ableitet.
+            Der größte Unterschied liegt darin, dass der Parameterraum nicht diskret sondern kontinuierlich ist.
+            Das bedeutet, das jeder Punkt unendlich viele Nachbarn hat.
+            Durch die Bestimmung des \textbf{Gradienten} kann die Richtung des steilsten Abstiegs angegeben werden:
+            \large
+            $$\Delta g= \begin{bmatrix}
+                \frac{\delta g}{\delta w_1}\\
+                \frac{\delta g}{\delta w_2}\\
+                \vdots\\
+                \frac{\delta g}{\delta w_n}
+            \end{bmatrix}
+            $$
+            \normalsize
+            Zu beginn werden die Gewichte $w$ des Neuronen definiert (zufällig oder anders).
+            Anschließend werden sie bei jeder Iteration über 
+            \large
+            $$w\gets w+\alpha\cdot \Delta g(w)$$
+            \normalsize
+            umdefiniert.
+            Hierbei ist $\alpha$ ein Hyperparamter, der die \textbf{Lernrate} definiert.\\
+            Zu erwähnen ist noch, dass auch hier wie beim Hill-Climbing (Zusammenfassung KI: Hill Climbing) die Gefahr besteht,
+            dass lediglich ein lokales anstatt dem globalen Minimum gefunden wird.
+
+        \subsection{Backpropagation}
+        \label{knn: backpropagation}
+            Da der Fehler, den die Fehlerfunktion angibt auf alle Schichten zurückzuführen ist,
+            muss auch die Optimierung Rückwärtsgerichtet in allen Schichten stattfinden.
+            Man spricht hierbei von einer \say{Backpropagation}.\\
+            Um ein Ausgangsneuron zu updaten muss die Fehlerfunktion
+            $$f(a,t) = \sum_i \frac{1}{2}(a_i-t_i)^2$$
+            erstmal auf den Ausgabewert des jeweiligen Neurons abgeleitet werden:
+            $$\frac{\delta f}{\delta a_i}=a_i-t$$
+            Wenn man dies nun auf die Zustandsfunktion des Neurons ableitet erhält man:
+            $$\frac{\delta f}{\delta z_i} = \frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}$$
+            Um die Änderung für eine Gewichtung $g_{ij}$ zu bestimmen muss die Fehlerfunktion nun zunächst auf dieses $g_{ij}$ abgeleitet werden:
+            $$\frac{\delta f}{\delta g_{ij}} = \frac{\delta f}{\delta z_i} \cdot\frac{\delta z_i}{\delta g_{ij}} = \frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}\cdot\frac{\delta z_i}{\delta g_{ij}}$$
+            Nun kann man durch Einsetzen der verwendeten $f$, $a_i$ und $z_i$ die Formel für die Änderung von $g_{ij}$ aufstellen.\\
+            \textbf{Beispiel:}
+            \Large
+            \begin{tabbing}
+                $f(a,t)=\sum_i\frac{1}{2}(a_i-t_i)^2$\hspace{5mm}\=und\hspace{5mm}\=$\frac{\delta f}{\delta a_i}=a_i-t_i$\\\\
+                $a_i =\frac{1}{a+e^{z_i}}$ \>und \>$\frac{\delta a_i}{\delta z_i}=a_i(1-a_i)$\\\\
+                $z_i=\sum^{N+1}_{j=1}g_{ij}\cdot a_i$ \>und \>$\frac{\delta z_i}{\delta g_{ij}}=a_j$
+            \end{tabbing}
+            \normalsize
+            Hieraus ergibt sich:
+            $$\frac{\delta f}{\delta g_{ij}} = \frac{\delta f}{\delta z_i} \cdot\frac{\delta z_i}{\delta g_{ij}} = \frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}\cdot\frac{\delta z_i}{\delta g_{ij}}=(a_i-t_i)\cdot a_i(1-a_i)\cdot a_j$$
+            Da uns alle diese Werte bekannt sind können wir $g_{ij}$ updaten:
+            \large
+            $$g_{ij}\gets g_{ij} + \alpha\cdot\left((a_i-t_i)\cdot a_i(1-a_i)\cdot a_j\right)$$
+            \normalsize
+            Um die Backpropagation nun bei den anderen Neuronen auf tieferen Schichten anzuwenden muss auf diese abgeleitet werden:\\
+            \begin{wrapfigure}{r}{.4\textwidth}
+                \vspace{-10mm}
+                \includegraphics[width = .4\textwidth]{backpropagation_inner_layer.png}
+            \end{wrapfigure}
+
+            \begin{align*}
+                \frac{\delta f}{\delta a_i}&=(a_i-t_i)\\
+                \frac{\delta f}{\delta z_i}&=\frac{\delta f}{\delta a_i}\cdot\frac{\delta a_i}{\delta z_i}=a_i(1-a_i)\frac{\delta f}{\delta a_i}\\
+                \frac{\delta f}{\delta g_{ij}}&=\frac{\delta f}{\delta z_i}\cdot\frac{\delta z_i}{\delta g_{ij}} = a_j\frac{\delta f}{\delta z_i}\\
+                \frac{\delta f}{\delta a_j}&=\sum_i\frac{\delta f}{\delta z_i}\cdot\frac{\delta z_i}{\delta a_j}=\sum_i g_{ij}\frac{\delta f}{\delta z_i}
+            \end{align*}
+            Die Summe wird durch die Mehrzahl der Nachfolgenden Neuronen von $B_j$ berursacht.

chapters/Unsupervised Learning/Aufgaben.tex

@@ -0,0 +1,21 @@
+\chapter{Aufgaben des unüberwachten Lernens}
+\label{aufgaben unsupervised learning}
+    Das unüberwachte Lernen wird in der Praxis für die verschiedensten Aufgabenfelder angewandt:
+
+        \paragraph{Clustering} siehe \ref{clustering}
+
+        \paragraph{Anomaliedetektion}
+        Das Erkennen von Anomalien ist eine weitere Aufgabe des unüberwachten Lernen.
+        Anomalien sind beispielsweise ungewöhnliche Transaktionen auf Kreditkarten, die auf Betrug hindeuten,
+        das Abfangen von Produktionsfehlern oder das automatische Entfernen von Ausreißern aus einem Datensatz,
+        bevor dieser in einen weiteren Lernalgorithmus eingespeist wird.
+        Das System wird mit gewähnlichen Datenpunkten trainiert und kann,
+        wenn es einen neuen Datenpunkt sieht, entscheiden, ob dieser wie ein normaler Punkt oder wie eine Anomalie aussieht.
+
+        \paragraph{Dichteschätzung}
+        Wie auch beim Clustering (\ref{clustering}) spricht man bei der Dichteschätzung von unüberwachtem Lernen.
+        Hier stehen die Ausgabewerte nicht zur Verfügung und nur die Eingabedaten sind bekannt.
+        Das Ziel besteht darin, die Regelmäßigkeiten in den Eingabedaten aufzuspüren.
+        Dh.h. es existiert eine Struktur in den Eingabedatem, so dass bestimmte Muster öfter auftreten als andere.
+        In der Statistik nennt man die Dichteschätzung \say{density estimation}.
+        Eine Möglichkeit der Dichteschätzung ist das \acs{DBSCAN}-Verfahren (\ref{density based clustering}).

chapters/Unsupervised Learning/Clustering.tex

@@ -1,4 +1,5 @@
 \chapter{Clustering}
+\label{clustering}
     \section{Definition}
         Allgemein gesagt bestimmt ein Clustering-Verfahren, ob zwei Elemente ähnlich bzw. unähnlich sind.\\
         \includegraphics[width = .6\textwidth]{clustering_definition.png}\\
@@ -83,6 +84,22 @@
         Diese lassen sich allerdings auch kombinieren.
         Alle internen Bewertungskriterien haben gemein, dass sie keine Informationen ausserhalb der Datenbasis in dei Bewertung einschließen.\\
         Externe Bewertungskriterien vergleichen meist extern bekannte Beziehungen mit den vom Clustering Algorithmus ermittelten.
-        Ein Beispiel für ein externes Bewertungskriterium ist der \say{Rand indicator}:
-        $$ RI = \frac{TP+TN}{TP+FP+FN+TN} $$
+        Beispiele für externe Bewertungskriterien sind (weitere unter \href{https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers}{https://en.wikipedia.org/wiki/Evaluation\_of\_binary\_classifiers}):\\
+        ($TP:$ True Positive; $TN:$ True Negative; $FN:$ False Negative; $FP:$ False Positive)
+
+        \paragraph{Accuracy}
+            $$ACC=\frac{TP+TN}{P+NP}=\frac{TP+TN}{TP+TN+FP+FN}$$
+            Die Accuracy hat den Nachteil, dass sie nur den gesamten relativen Fehler angibt.
+            Dies ist vor allem dann problematisch, wenn eine bestimmte Klasse nur wenig Daten im Datensatz hat.\\
+            \textbf{Beispiel:} Eine Wettervorhersage, die nie Regen vorhersagt hat eine hohe Accuracy, da es nur mit einer geringen Wahrscheinlichkeit regnet.
         
+        \paragraph{Precision}
+            $$P=\frac{TP}{TP+FP}$$
+            Wird auch als \ac{PPV} bezeichnet
+
+        \paragraph{Recall}
+            $$R=\frac{TP}{TP+FN}$$
+            Wird auch als \ac{TPR} bezeichnet
+        
+        \paragraph{F1-Maß}
+            $$F_1=2\cdot\frac{P\cdot R}{P+R}=\frac{2TP}{2TP+FP+FN}$$

parts/Semi-supervised Learning.tex

@@ -1,3 +1,4 @@
 \part{Semi-supervised Learning}
 
-\input{chapters/Semi-supervised Learning/Deep Learning.tex}
+\input{chapters/Semi-supervised Learning/Deep Learning.tex}
+\input{chapters/Semi-supervised Learning/CNN.tex}

parts/Unsupervised Learning.tex

@@ -1,5 +1,6 @@
 \part{Unsupervised Learning}\label{unsupervised learning}
 
+\input{chapters/Unsupervised Learning/Aufgaben.tex}
 \input{chapters/Unsupervised Learning/Clustering.tex}
 \input{chapters/Unsupervised Learning/Clustering Algorithms.tex}
 \input{chapters/Unsupervised Learning/Number of Clusters.tex}