+Titanic Classifier

7f7f72b8 · hachmeis@hu-berlin.de · 57236942 · 7f7f72b8
Commit 7f7f72b8 authored 1 year ago by hachmeis@hu-berlin.de
--- a/programmierspass/Data_Mining.ipynb
+++ b/programmierspass/Data_Mining.ipynb
 {
 "cells": [
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "little-production",
   "metadata": {},
@@ -20,6 +21,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "rising-farming",
   "metadata": {},
@@ -41,6 +43,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "60ef8533",
   "metadata": {},
@@ -72,6 +75,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "88429751",
   "metadata": {},
@@ -85,6 +89,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "2f2a0afc",
   "metadata": {},
@@ -109,6 +114,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "91ec21a4",
   "metadata": {},
@@ -139,6 +145,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "collected-genius",
   "metadata": {},
@@ -162,11 +169,362 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "df = sns.load_dataset('iris')\n",
+    "df = sns.load_dataset('titanic')\n",
    "df.head()\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3a49871e",
+   "metadata": {},
+   "source": [
+    "# Preprocessing: Columns to keep:\n",
+    "- survived/alive --> binary\n",
+    "- pclass & class zusammen --> ordinary\n",
+    "- sex/who --> binary\n",
+    "- age --> int/float\n",
+    "- parch--> \n",
+    "- fare --> float\n",
+    "- embarked --> class\n",
+    "- adult_male --> binary\n",
+    "- deck --> class\n",
+    "- embark_town --> class\n",
+    "- alone --> binary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e42d157a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df[\"survived\"]\n",
+    "df[\"alive\"] = df[\"alive\"].apply(lambda x: 1 if x == \"yes\" else 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0b31b9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df.drop([\"alive\", \"who\", \"deck\"], axis=1)\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "be414200",
+   "metadata": {},
+   "source": [
+    "# Spalten kodieren\n",
+    "- sklearn Encodern\n",
+    "- Pandas encoding"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f65e19c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d69ef59e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Spalten zum ordinal kodieren\n",
+    "ordinal_cols = [\"sex\", \"pclass\", \"adult_male\", \"alone\"]\n",
+    "                \n",
+    "                # OneHotEncoding Columns\n",
+    "onehot_cols = [\"embarked\"]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa0cc913",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df[ordinal_cols]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "145a7892",
+   "metadata": {},
+   "source": [
+    "# Ordinales Encoden"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d29be5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.preprocessing import OrdinalEncoder\n",
+    "\n",
+    "\n",
+    "# reduce dataframe to cols to encode ordinally\n",
+    "df_ord = df[ordinal_cols]\n",
+    "\n",
+    "enc = OrdinalEncoder()\n",
+    "\n",
+    "# tell the encoder how to encode\n",
+    "enc.fit(df_ord)\n",
+    "\n",
+    "enc.categories_\n",
+    "\n",
+    "# transform the dataframe\n",
+    "X_ord = enc.transform(df_ord)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7242b07d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df[onehot_cols]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e962c970",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.preprocessing import OneHotEncoder\n",
+    "\n",
+    "\n",
+    "# reduce dataframe to cols to encode ordinally\n",
+    "df_onehot = df[onehot_cols]\n",
+    "\n",
+    "enc = OneHotEncoder(handle_unknown='ignore')\n",
+    "\n",
+    "# tell the encoder how to encode\n",
+    "enc.fit(df_onehot)\n",
+    "\n",
+    "enc.categories_\n",
+    "\n",
+    "# transform the dataframe\n",
+    "X_onehot = enc.transform(df_onehot)\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "060a8fcf",
+   "metadata": {},
+   "source": [
+    "# Numpy Package importieren"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5cd9c8ef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
    "\n"
   ]
  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "25c8c6c6",
+   "metadata": {},
+   "source": [
+    "## Matrizen zusammenhängen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbd6df67",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = np.concatenate((X_ord, X_onehot.todense()), axis=1)\n",
+    "\n",
+    "X_onehot.shape"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "ad399bfb",
+   "metadata": {},
+   "source": [
+    "# Label absplitten"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ceffbb2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X\n",
+    "y = df.survived.values"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "2e2601be",
+   "metadata": {},
+   "source": [
+    "# Train Test Split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5521f70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)\n",
+    "\n",
+    "X_train = np.array(X_train) \n",
+    "X_test = np.array(X_test)\n",
+    "y_train = np.array(y_train)\n",
+    "y_test = np.array(y_test)\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "6d8f5935",
+   "metadata": {},
+   "source": [
+    "# Modelle trainieren"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "f63616a2",
+   "metadata": {},
+   "source": [
+    "## Naive Bayes Estimator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b106a7a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "\n",
+    "\n",
+    "gnb = GaussianNB()\n",
+    "\n",
+    "# Modell Training\n",
+    "gnb.fit(X_train, y_train)\n",
+    "\n",
+    "# Vorhersagen Trainingsset\n",
+    "y_pred = gnb.predict(X_test)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d2fcba4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Number of mislabeled points out of a total %d points : %d\"\n",
+    "      % (X_test.shape[0], (y_test != y_pred).sum()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0300a959",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import confusion_matrix\n",
+    "\n",
+    "confusion_matrix(y_true=y_test, y_pred=y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "683327a8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "1000a61b",
+   "metadata": {},
+   "source": [
+    "## K-Nearest Neighbors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68c97117",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_ord[:20]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14eeb8ca",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "324cb959",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.deck.value_counts()"
+   ]
+  },
  {
   "cell_type": "code",
   "execution_count": null,
@@ -234,6 +592,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "fixed-corporation",
   "metadata": {},
@@ -247,6 +606,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "26e3add5",
   "metadata": {},
@@ -286,6 +646,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "bae8b8bf",
   "metadata": {},
@@ -296,6 +657,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "1216f42c",
   "metadata": {},
@@ -304,6 +666,7 @@
   ]
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "6644498a",
   "metadata": {},
@@ -320,6 +683,7 @@
   "source": []
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "1b58a4cb",
   "metadata": {},
@@ -336,6 +700,7 @@
   "source": []
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "67a56b07",
   "metadata": {},
@@ -352,6 +717,7 @@
   "source": []
  },
  {
+   "attachments": {},
   "cell_type": "markdown",
   "id": "730b3c58",
   "metadata": {},

 %% Cell type:markdown id:little-production tags:
 # Data Mining
 <br/>
 <br/>
 Dieses Notebook finden Sie hier: https://scm.cms.hu-berlin.de/ibi/python/-/blob/master/programmierspass/Data_Mining.ipynb
 <br/>
 ![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
 Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
 %% Cell type:markdown id:rising-farming tags:
 ## Was ist es und worum geht es?
 **Data Mining** wird wie folgt definiert:
 - **Definition 1 (Synonym zu *Knowledge Discovery in Databases (KDD)*)**: Prozess der (semi-) automatischen Extraktion von Wissen aus Datenbanken, das statistisch gültig, bisher unbekannt und potentiell nützlich ist. [1]
 - **Definition 2 (Teil des KDD)**:
    - Mustergewinnung/Modellierung
    - Interpretation
    - Anwendung von Algorithmen, die unter gewissen Ressourcenbeschränkungen Muster/Modelle bei gegebener Faktenmenge erzeugen
 **Anwendungsfälle**
 - Spamfilterung
 - Objekterkennung auf Bildern
 - Prüfung der Kreditwürdigkeit von potentiellen Kunden
 - Personalisierte Empfehlungen (zum Beispiel auf YouTube und Spotify)
 %% Cell type:markdown id:60ef8533 tags:
 ## Ziel für heute
 - kurze Einführung in das Thema
 - Anwendungsbeispiele zeigen
 - Teaser für die Master-Lehrveranstaltungen *Knowledge Discovery in Databases (KDD)* und *Web Science*
 - Inspiration :)
 %% Cell type:markdown id:e0ffe431 tags:
 ## Prozess-Model des Data Mining [1]
 ![Screenshot%20from%202023-01-26%2011-31-48.png](attachment:Screenshot%20from%202023-01-26%2011-31-48.png)
 **Referenzen**
 [1]: (Fayyad, Piatetsky-Shapiro und Smyth 1996) https://ojs.aaai.org//index.php/aimagazine/article/view/1230
 %% Cell type:markdown id:88429751 tags:
 ### Data Mining Tasks
 - **Clustering**
 - **Klassifikation**
 - Regression
 - Assoziationsregeln
 - ...
 %% Cell type:markdown id:2f2a0afc tags:
 ## Python Bibliotheken die wir heute benutzen:
 - [Pandas](https://pandas.pydata.org/) für die **Vorverarbeitung**
 - [Seaborn](https://seaborn.pydata.org/) und [Matplotlib](https://matplotlib.org/) zur **Visualisierung**
 - [Scikit Learn](https://scikit-learn.org/stable/) zur **Implementierung von Algorithmen** und deren **Evaluation**
 %% Cell type:code id:broadband-bathroom tags:
 ``` 
 import pandas as pd
 import seaborn as sns
 import matplotlib.pyplot as plt
 ```
 %% Cell type:markdown id:91ec21a4 tags:
 ## Wie entscheide ich mich für ein Modell?
 Abgeleitet vom Ziel der Data Mining Anwendung, wird ein Modell auf Basis des jeweiligen Tasks (Klassifikation, Clustering, Regression, Assoziationsregeln, ...) gewählt. Es gibt eine Vielzahl von Modellen. Eine erste Heuristik zur Entscheidung für angemessene Modelle zum experimentieren bietet [SciKit Learn's Machine Learning Map](https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html). Allerdings, hat auch die Bibliothek von SciKit Learn seine Grenzen. Assoziationsregeln sind hier nicht implementiert und auch komplexere Ansätze die auf Neuronalen Netzen basieren, werden üblicherweise mit anderen Bibliotheken implementiert wie bspw. [PyTorch](https://pytorch.org/), [Tensorflow](https://www.tensorflow.org/) oder [Keras](https://keras.io/). Ein paar Beispiele die typischerweise verwendet werden in den jeweiligen Tasks:
 **Clustering**
 - K-Means
 - DBSCAN
 **Klassifikation**
 - Naive Bayes Klassifikator
 - Decision Trees
 - Random Forests
 - Support Vector Machines
 - Neural Networks (bspw. Convolutional Neural Networks, Transformers)
 **Regression**
 - SGD Regressor
 - RidgeRegression
 **Assoziationsregeln**
 - Apriori Algorithm
 - Eclat
 %% Cell type:markdown id:collected-genius tags:
 # Clustering
 Welche Ähnlichkeitsstrukturen liegen in den Daten vor?
 Beispiele:
 - Welche Gruppen von Kunden sind in der Datenbank?
 - Welche Genre sind in der Musiklandschaft vorhanden?
 ### Exploration
 %% Cell type:code id:dd3d70cf tags:
 ``` 
-df = sns.load_dataset('iris')
+df = sns.load_dataset('titanic')
 df.head()
+```
+%% Cell type:markdown id:3a49871e tags:
+# Preprocessing: Columns to keep:
+- survived/alive --> binary
+- pclass & class zusammen --> ordinary
+- sex/who --> binary
+- age --> int/float
+- parch-->
+- fare --> float
+- embarked --> class
+- adult_male --> binary
+- deck --> class
+- embark_town --> class
+- alone --> binary
+%% Cell type:code id:e42d157a tags:
+``` 
+df["survived"]
+df["alive"] = df["alive"].apply(lambda x: 1 if x == "yes" else 0)
+```
+%% Cell type:code id:c0b31b9c tags:
+``` 
+df = df.drop(["alive", "who", "deck"], axis=1)
+```
+%% Cell type:markdown id:be414200 tags:
+# Spalten kodieren
+- sklearn Encodern
+- Pandas encoding
+%% Cell type:code id:8f65e19c tags:
+``` 
+df
+```
+%% Cell type:code id:d69ef59e tags:
+``` 
+# Spalten zum ordinal kodieren
+ordinal_cols = ["sex", "pclass", "adult_male", "alone"]
+                # OneHotEncoding Columns
+onehot_cols = ["embarked"]
+```
+%% Cell type:code id:aa0cc913 tags:
+``` 
+df[ordinal_cols]
+```
+%% Cell type:markdown id:145a7892 tags:
+# Ordinales Encoden
+%% Cell type:code id:8d29be5c tags:
+``` 
+from sklearn.preprocessing import OrdinalEncoder
+# reduce dataframe to cols to encode ordinally
+df_ord = df[ordinal_cols]
+enc = OrdinalEncoder()
+# tell the encoder how to encode
+enc.fit(df_ord)
+enc.categories_
+# transform the dataframe
+X_ord = enc.transform(df_ord)
+```
+%% Cell type:code id:7242b07d tags:
+``` 
+df[onehot_cols]
+```
+%% Cell type:code id:e962c970 tags:
+``` 
+from sklearn.preprocessing import OneHotEncoder
+# reduce dataframe to cols to encode ordinally
+df_onehot = df[onehot_cols]
+enc = OneHotEncoder(handle_unknown='ignore')
+# tell the encoder how to encode
+enc.fit(df_onehot)
+enc.categories_
+# transform the dataframe
+X_onehot = enc.transform(df_onehot)
+```
+%% Cell type:markdown id:060a8fcf tags:
+# Numpy Package importieren
+%% Cell type:code id:5cd9c8ef tags:
+``` 
+import numpy as np
+```
+%% Cell type:markdown id:25c8c6c6 tags:
+## Matrizen zusammenhängen
+%% Cell type:code id:fbd6df67 tags:
+``` 
+X = np.concatenate((X_ord, X_onehot.todense()), axis=1)
+X_onehot.shape
+```
+%% Cell type:markdown id:ad399bfb tags:
+# Label absplitten
+%% Cell type:code id:ceffbb2b tags:
+``` 
+X
+y = df.survived.values
+```
+%% Cell type:markdown id:2e2601be tags:
+# Train Test Split
+%% Cell type:code id:c5521f70 tags:
+``` 
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
+X_train = np.array(X_train)
+X_test = np.array(X_test)
+y_train = np.array(y_train)
+y_test = np.array(y_test)
+```
+%% Cell type:markdown id:6d8f5935 tags:
+# Modelle trainieren
+%% Cell type:markdown id:f63616a2 tags:
+## Naive Bayes Estimator
+%% Cell type:code id:b106a7a3 tags:
+``` 
+from sklearn.naive_bayes import GaussianNB
+gnb = GaussianNB()
+# Modell Training
+gnb.fit(X_train, y_train)
+# Vorhersagen Trainingsset
+y_pred = gnb.predict(X_test)
+```
+%% Cell type:code id:d2fcba4b tags:
+``` 
+print("Number of mislabeled points out of a total %d points : %d"
+      % (X_test.shape[0], (y_test != y_pred).sum()))
+```
+%% Cell type:code id:0300a959 tags:
+``` 
+from sklearn.metrics import confusion_matrix
+confusion_matrix(y_true=y_test, y_pred=y_pred)
+```
+%% Cell type:code id:683327a8 tags:
+``` 
+```
+%% Cell type:markdown id:1000a61b tags:
+## K-Nearest Neighbors
+%% Cell type:code id:68c97117 tags:
+``` 
+X_ord[:20]
+```
+%% Cell type:code id:14eeb8ca tags:
+``` 
+```
+%% Cell type:code id:324cb959 tags:
+``` 
+df.deck.value_counts()
 ```
 %% Cell type:code id:f606e9d2 tags:
 ``` 
 from sklearn.cluster import KMeans
 import numpy as np
 # feature extraction
 X = df.drop('species', axis=1)
 # model initialization
 kmeans = KMeans(n_clusters=3)
 # training
 kmeans.fit(X)
 #
 y_pred = kmeans.predict(X)
 # assign predictions
 df['predicted'] = y_pred
 ```
 %% Cell type:code id:6adb3d3d tags:
 ``` 
 # Ergebnisse plotten
 sns.scatterplot(data=df, x='sepal_length', y='petal_width', hue='predicted', style='species')
 plt.title('Clusters based on KMeans')
 plt.show()
 ```
 %% Cell type:code id:39fbe1e9 tags:
 ``` 
 from sklearn.cluster import DBSCAN
 import numpy as np
 # init DBSCAN
 dbscan = DBSCAN(eps=1, min_samples=2)
 # train and predict DBSCAN
 y_pred2 = dbscan.fit_predict(X)
 #
 df["predict2"] = y_pred
 sns.scatterplot(data=df, x='sepal_length', y='petal_width', hue='predict2', style='species')
 plt.title('Clusters based on DBSCAN')
 plt.show()
 ```
 %% Cell type:markdown id:fixed-corporation tags:
 ## Klassifikation
 Beispiele:
 - Objekt-Klassifizierung
 - Kreditwürdigkeitsprüfung
 %% Cell type:markdown id:26e3add5 tags:
 ### Exploration
 %% Cell type:code id:64300d50 tags:
 ``` 
 from sklearn.datasets import load_iris
 from sklearn.model_selection import train_test_split
 from sklearn.naive_bayes import GaussianNB
 df = sns.load_dataset('iris')
 X = df.drop('species', axis=1)
 y = df['species']
 # train and test set split with a test set size of 50%
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
 # initialize Naive Bayes Classifier
 gnb = GaussianNB()
 # training
 gnb.fit(X_train, y_train)
 # predict
 gnb.predict(X_test)
 # Evaluation
 gnb.score(X_test, y_test)
 ```
 %% Cell type:markdown id:bae8b8bf tags:
 <div class="alert alert-info">
 Wir haben hier *nur* die Accuracy berechnet. Generell gibt es noch weitere Metriken die zur Evaluation von Klassifikationsverfahren verwendet werden können. Beispielsweise: **Precision, Recall und F1 Score.**
 </div>
 %% Cell type:markdown id:1216f42c tags:
 ## Klassifikation auf Textdaten
 %% Cell type:markdown id:6644498a tags:
 ### Exploration
 %% Cell type:code id:bf0bbab7 tags:
 ``` 
 ```
 %% Cell type:markdown id:1b58a4cb tags:
 ### Vorverarbeitung
 %% Cell type:code id:e46bc6d3 tags:
 ``` 
 ```
 %% Cell type:markdown id:67a56b07 tags:
 ### Training
 %% Cell type:code id:63ea7162 tags:
 ``` 
 ```
 %% Cell type:markdown id:730b3c58 tags:
 ### Evaluation
 %% Cell type:code id:a9f736fb tags:
 ``` 
 ```