dc_notebook.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ichoosetoaccept/awesome-design-patterns/blob/master/dc_notebook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g7v23sltFG3P"
      },
      "source": [
        "# &#127794; Digital Champion - Python Session"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "flo0AopoFG3T"
      },
      "source": [
        "## &#128210; Inhaltsverzeichnis:\n",
        "* [1 Einführung](#first-bullet)\n",
        "* [2 Entscheidungsbäume Theorie & Aufgabenstellung](#second-bullet)\n",
        "* [3 Datenaufbereitung](#third-bullet)\n",
        "* [4 Einfacher Entscheidungsbaum](#fourth-bullet)\n",
        "* [5 Optimierter Entscheidungsbaum](#fifth-bullet)\n",
        "* [6 Abschluss](#sixth-bullet)\n",
        "* [7 Anhang](#seventh-bullet)\n",
        "* [8 Lösungen](#eight-bullet)\n",
        "* [9 Quellen](#nineth-bullet)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DnVZt8JsFG3U"
      },
      "source": [
        "<a name=\"first-bullet\"></a>\n",
        "## 1 Einführung (4 min)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "88DZNQTMFG3U"
      },
      "source": [
        "Jupyter Notebooks sind interaktive Entwicklungsumgebungen, die es ermöglichen, Code, Visualisierungen und Text in einer einzigen Umgebung zu kombinieren. Sie werden häufig für die Datenanalyse, den Code-Austausch und die Dokumentation verwendet. Mit Jupyter Notebooks können Python-Codezellen ausgeführt und die Ergebnisse sofort angezeigt werden. In diesem Jupyter-Notebook werden wir ```Entscheidungsbäume``` betrachten.\n",
        "\n",
        "![alt text for screen readers](./pictures/google-intro.png \"Einführung Jupyter Notebook\").\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "### Erklärungen:\n",
        "\n",
        "* &#9654; **Ausführen:** Mit diesem Symbol können wir den Code in einer Zelle ausführen\n",
        "\n",
        "* &#128465; **Löschen:** Mit diesem Symbol können wir eine Zelle löschen und deren Inhalt entfernen\n",
        "\n",
        "* ```Text``` Markdown-Zellen dienen zur Eingabe und Formatierung von Text. Sie ermöglichen es, Text, Überschriften, Aufzählungen, Bilder und andere Formatierungselemente einzufügen\n",
        "\n",
        "* ```Code``` Code-Zellen werden verwendet, um ausführbaren Code einzugeben. In einer Code-Zelle können Programmiersprachen wie Python, R, Julia und andere verwendet werden"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O1v9BxC0FG3V"
      },
      "source": [
        "> **INFO:**\n",
        "> \n",
        "> - Wir lesen das Notebook durch und bearbeiten die Aufgaben direkt in diesem Notebook\n",
        ">     \n",
        "> - Die Lösungen können wir mit dem Link unter den Aufgaben aufrufen\n",
        ">     \n",
        "> - Fragen bitte direkt in den Chat schreiben\n",
        "> \n",
        "> - Komplexere Fragen werden in Breakout-Sessions behandelt\n",
        "> \n",
        "> - Zu jedem Kapitel gibt es eine Zeitangabe, diese sollte man einhalten, wenn man durch das Ganze Notebook durchgehen möchte\n",
        ">     \n",
        "> - Aufgabe 1, 2 und 3 müssen gelöst werden, um dem Notebook weiter zu folgen (bei Zeitproblemen Lösungen kopieren)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z5aMcYc-FG3W"
      },
      "source": [
        "<a name=\"second-bullet\"></a>\n",
        "## 2 Entscheidungsbäume Theorie & Aufgabenstellung (7 min)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EDJRMSTLFG3X"
      },
      "source": [
        "### 2.1 Was ist ein Entscheidungsbaum?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfDNAdT8FG3Y"
      },
      "source": [
        "Entscheidungsbäume sind eine Methode zur automatischen Klassifizierung von Beobachtungen (z.B. Personen etc.) und damit zur Lösung von Entscheidungsproblemen. Ein Entscheidungsbaum besteht immer aus einem Wurzelknoten (root node) und beliebig vielen inneren Knoten (split node) sowie mindestens zwei Blättern (leaf node). Dabei repräsentiert jeder Knoten eine logische Regel und jedes Blatt eine Antwort auf das Entscheidungsproblem. Im Folgenden ist ein Beispiel für einen Entscheidungsbaum abgebildet:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VTzCPg0fFG3Y"
      },
      "source": [
        "![alt text for screen readers](./pictures/dt-example-new.png \"Beispiel Entscheidungsbaum\")."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uY0G6Av7FG3Z"
      },
      "source": [
        "Mit dem abgebildeten Entscheidungsbaum wollen wir mit den Informationen von ```income_usd``` und ```with_mortage``` herausfinden, ob eine Person eine Versicherung hat.\n",
        "\n",
        "Die folgenden Informationen sind üblicherweise im Entscheidungsbaum abgebildet:\n",
        "* **gini:** Der Gini-Index beschreibt, wie gut ein Knoten verschiedene Klassen (z.B. ```No Insurance```, ```Has Insurance```) separiert. Der Wert ist immer zwischen 0 und 1. Je kleiner der Gini-Index ist desto besser. Bei der Konstruktion des Entscheidungsbaumes kann der Gini-Index berechnet werden. Es wird immer die logische Regel gewählt, welche den besten Gini-Index aufweist.\n",
        "* **samples:** Dieser Wert beschreibt die Anzahl Beobachtungen (z.B. Daten von Personen), welche für den Split eines spezifischen Knoten zur Verfügung stehen. Wir sehen beispielsweise, dass für die Konstruktion dieses Baumes Daten von 24 Personen verwendet wurden. Weiter sehen wir, dass der erste Knoten die 24 Personen in eine Gruppe mit 13 und eine Gruppe mit 11 Personen aufteilt.\n",
        "* **value:** Value beschreibt, wie die Aufteilung der ```samples``` im Knoten aussieht. Der Wert ```[15, 9]``` im ersten Knoten beschreibt beispielsweise, dass von 24 Personen 15 keine Versicherung und 9 Personen eine Versicherung haben.\n",
        "* **class:** Dieser Wert steht für die Klasse, für welche ein spezifischer Knoten steht. Beispiel: Im ersten Knoten sehen wir, die Klasse ```No insurance```, da von den 24 Personen mehr ```No Insurance``` (15) haben, als ```Has Insurance``` (9). Anhand der Farbe kann ebenfalls die Klasse abgelesen werden. Je röter ein Knoten ist, je mehr gehört er zur Klasse ```No Insurance``` und je blauer ein Knoten ist, je mehr gehört er zur Klasse ```Has Insurance```.\n",
        "\n",
        "> **INFO:**<br>\n",
        "> Wie kann man einen Entscheidungsbaum lesen bzw. wie klassifizert der Entscheidungsbaum neue Beobachtungen (z.B. Personen):\n",
        "> \n",
        "> - Wir starten immer beim Wurzelknoten, d.h. ganz oben im Entscheidungsbaum\n",
        "> \n",
        "> - Wenn die logische Regel im Knoten für die neue Beobachtung erfüllt ist, geht man nach links und wenn sie nicht erfüllt ist, geht man nach rechts\n",
        "> \n",
        "> - Wir durchlaufen den Baum so lange, bis wir bei einem Blatt ankommen. Das ```class``` Attribute im Blatt beschreibt die Klasse der neuen Beobachtung\n",
        "\n",
        "</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TOGRpSGFFG3Z"
      },
      "source": [
        "> **AUFGABE 1:** <br>\n",
        "> Bestimme die Klasse der beiden nachfolgeden Personen anhand des oben abgebildeten Entscheidungsbaums:\n",
        ">\n",
        "> - Person 1: income_usd = 100'000; with_mortage = 0\n",
        ">\n",
        "> - Person 2: income_usd = 73'000; with_mortage = 1\n",
        ">\n",
        "> -> Lösungen zu [Aufgabe 1](#lösung_aufgabe_1)\n",
        ">   \n",
        "> -> Falls du keine Lösung findest, kopiere die Lösung aus dem Link"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0Z8srHfLFG3a"
      },
      "outputs": [],
      "source": [
        "# Eigene Lösung (mit Kommentarfunktion '#' einfügen):\n",
        "# Person 1: Has insurance\n",
        "# Person 2: Has insurance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kkJHFLvxFG3b"
      },
      "source": [
        "### 2.2 Aufgabenstellung\n",
        "\n",
        "In diesem Jupyter-Notebook arbeiten wir mit dem ['heart-disease'](https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/) (HD) Datenset. Das Datenset ist eine Tabelle mit 14 Spalten (Features) und 303 Zeilen (Beobachtungen). Eine kurze Beschreibung der verschiedenen Features:\n",
        "* age: Alter\n",
        "* sex: Mann/Frau\n",
        "* restbp: resting blood pressure (Ruheblutdruck (in mm Hg bei Aufnahme ins Krankenhaus))\n",
        "* chol: Serumcholesterin in mg/dl\n",
        "* fbs: wenn der Nüchternblutzucker > 120 mg/dl liegt\n",
        "* thalach: maximale Herzfrequenz erreicht\n",
        "* exang: Belastungsangina (Richtig/Falsch)\n",
        "* oldpeak: ST-Depression durch körperliche Betätigung im Vergleich zur Ruhe\n",
        "* ca: Anzahl der großen Gefäße (0-3), gefärbt durch Fluoroskopie\n",
        "* hd: Art der Herzerkrankung\n",
        "\n",
        "Unser Ziel ist es, mit den 303 Beobachtungen ein Modell zu generieren, welches neue Beobachtungen (bzw. Personen) klassifizieren und somit bestimmen kann, ob eine Herzerkrankung (HD) vorliegt oder nicht. Im Modell nutzen wir die oben beschriebenen Features um die Zielvariable (HD) vorherzusagen:\n",
        "\n",
        "Wir verwenden einen Entscheidungsbaum für die Klassifikation von HD."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oVMUd4MeFG3c"
      },
      "source": [
        "<a name=\"third-bullet\"></a>\n",
        "## 3 Datenaufbereitung (10 min) <a class=\"anchor\" id=\"third-bullet\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bIetehYoFG3c"
      },
      "source": [
        "### 3.1 Read data\n",
        "\n",
        "Bei jedem neuen Python-Projekt überlegen wir uns, welche Python-Bibliotheken wir verwenden möchten. Eine Python-Bibliothek ist ein wiederverwendbarer Codeblock, den wir in einem Programm bzw. Projekt einbinden können. Das Einbinden von solchen Codeblocks ist einiges schneller als den Code selber zu schreiben.\n",
        "\n",
        "> **INFO:** <br> \n",
        "> Wenn wir in Python programmieren, ist es wichtig zu wissen, dass alles was hinter einem '#' steht kein Code ist, sondern nur ein Kommentar um den Code zu beschreiben."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "OkqaOFX0FG3c"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "pip install pandas numpy matplotlib scikit-learn"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "ybmQEjx_FG3c"
      },
      "outputs": [],
      "source": [
        "# Bibliotheken importieren\n",
        "# pandas: Daten lesen und bearbeiten\n",
        "import pandas as pd\n",
        "# numpy: berechnen von KPIs\n",
        "import numpy as np\n",
        "# plt: ploten von Grafiken\n",
        "import matplotlib.pyplot as plt\n",
        "# DecisionTreeClassifier: Modellierungskit für Entscheidungsbäume\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "# plot_tree: Entscheidungsbaum als Grafik ploten\n",
        "from sklearn.tree import plot_tree\n",
        "# train_test_split: Hilfe um Beobachtungen in Training- bzw. Testset zu splitten\n",
        "from sklearn.model_selection import train_test_split\n",
        "# cross_val_score: Kreuzvalidierung\n",
        "from sklearn.model_selection import cross_val_score\n",
        "# confusion_matrix: Konfusionsmatrix ploten\n",
        "from sklearn.metrics import confusion_matrix\n",
        "# ConfusionMatrixDispla: Konfusionsmatrix ploten\n",
        "from sklearn.metrics import ConfusionMatrixDisplay\n",
        "# accuracy_score: berechne die Accuracy\n",
        "from sklearn.metrics import accuracy_score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucnQWox3FG3d"
      },
      "source": [
        "> **INFO:** <br>\n",
        "> In Python kann man mit Hilft des '=' Operatros Daten in einer Variable speichern. Wenn wir beispielsweise die Zahl 5 in der Variable 'a' speichern möchten, können wir das mit dem folgenden Code machen:\n",
        "> <br><br>\n",
        "> a = 5 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "m4H8iKuRFG3d"
      },
      "outputs": [],
      "source": [
        "# pd.read_csv(filepath_or_buffer, sep, encoding) ermöglicht es '.csv' Daten einzulesen\n",
        "# und in einer Variable als Tabelle zu speichern\n",
        "df = pd.read_csv(filepath_or_buffer='https://raw.githubusercontent.com/alles-grob/dc-jupyter-notebook/main/data/processed_cleveland_small.csv',\n",
        "                 sep=',',\n",
        "                 encoding='latin')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "qrF2ILoVFG3d",
        "outputId": "c1a19c9f-6333-42eb-dec0-fe19cf64c492"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "      age  sex  restbp   chol  fbs  thalach  exang  oldpeak   ca  hd\n",
              "0    63.0  1.0   145.0  233.0  1.0    150.0    0.0      2.3  0.0   0\n",
              "1    67.0  1.0   160.0  286.0  0.0    108.0    1.0      1.5  3.0   1\n",
              "2    67.0  1.0   120.0  229.0  0.0    129.0    1.0      2.6  2.0   1\n",
              "3    37.0  1.0   130.0  250.0  0.0    187.0    0.0      3.5  0.0   0\n",
              "4    41.0  0.0   130.0  204.0  0.0    172.0    0.0      1.4  0.0   0\n",
              "..    ...  ...     ...    ...  ...      ...    ...      ...  ...  ..\n",
              "298  45.0  1.0   110.0  264.0  0.0    132.0    0.0      1.2  0.0   1\n",
              "299  68.0  1.0   144.0  193.0  1.0    141.0    0.0      3.4  2.0   1\n",
              "300  57.0  1.0   130.0  131.0  0.0    115.0    1.0      1.2  1.0   1\n",
              "301  57.0  0.0   130.0  236.0  0.0    174.0    0.0      0.0  1.0   1\n",
              "302  38.0  1.0   138.0  175.0  0.0    173.0    0.0      0.0    ?   0\n",
              "\n",
              "[303 rows x 10 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-67b5c108-5a25-441d-a47c-972c0845e300\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>sex</th>\n",
              "      <th>restbp</th>\n",
              "      <th>chol</th>\n",
              "      <th>fbs</th>\n",
              "      <th>thalach</th>\n",
              "      <th>exang</th>\n",
              "      <th>oldpeak</th>\n",
              "      <th>ca</th>\n",
              "      <th>hd</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>63.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>145.0</td>\n",
              "      <td>233.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>150.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>2.3</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>67.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>160.0</td>\n",
              "      <td>286.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>108.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>1.5</td>\n",
              "      <td>3.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>67.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>120.0</td>\n",
              "      <td>229.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>129.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>2.6</td>\n",
              "      <td>2.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>37.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>130.0</td>\n",
              "      <td>250.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>187.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>3.5</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>41.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>130.0</td>\n",
              "      <td>204.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>172.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>298</th>\n",
              "      <td>45.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>110.0</td>\n",
              "      <td>264.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>132.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.2</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>299</th>\n",
              "      <td>68.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>144.0</td>\n",
              "      <td>193.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>141.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>3.4</td>\n",
              "      <td>2.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>300</th>\n",
              "      <td>57.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>130.0</td>\n",
              "      <td>131.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>115.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>1.2</td>\n",
              "      <td>1.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>301</th>\n",
              "      <td>57.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>130.0</td>\n",
              "      <td>236.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>174.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>302</th>\n",
              "      <td>38.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>138.0</td>\n",
              "      <td>175.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>173.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>?</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>303 rows × 10 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-67b5c108-5a25-441d-a47c-972c0845e300')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-67b5c108-5a25-441d-a47c-972c0845e300 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-67b5c108-5a25-441d-a47c-972c0845e300');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "# wenn wir eine Variable aufrufen, wird sie geplottet\n",
        "df"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6YTKoalyFG3d"
      },
      "source": [
        "> **AUFGABE 2:** <br>\n",
        "> Speichere die Daten in der Variable 'df_start'\n",
        ">  \n",
        "> -> Lösungen zu [Aufgabe 2](#lösung_aufgabe_2) <br>\n",
        "> -> Falls du keine Lösung findest, kopiere die Lösung aus dem Link"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "tu0TruQ8FG3e"
      },
      "outputs": [],
      "source": [
        "# Eigene Lösung:\n",
        "df_start = df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "Je_gpo30FG3e",
        "outputId": "82cd64f4-d4d0-42e4-a056-a3e580735e35",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "    age  sex  restbp   chol  fbs  thalach  exang  oldpeak   ca  hd\n",
              "0  63.0  1.0   145.0  233.0  1.0    150.0    0.0      2.3  0.0   0\n",
              "1  67.0  1.0   160.0  286.0  0.0    108.0    1.0      1.5  3.0   1\n",
              "2  67.0  1.0   120.0  229.0  0.0    129.0    1.0      2.6  2.0   1\n",
              "3  37.0  1.0   130.0  250.0  0.0    187.0    0.0      3.5  0.0   0\n",
              "4  41.0  0.0   130.0  204.0  0.0    172.0    0.0      1.4  0.0   0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-9820bf74-def7-4df9-bce5-d591edbdb258\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>sex</th>\n",
              "      <th>restbp</th>\n",
              "      <th>chol</th>\n",
              "      <th>fbs</th>\n",
              "      <th>thalach</th>\n",
              "      <th>exang</th>\n",
              "      <th>oldpeak</th>\n",
              "      <th>ca</th>\n",
              "      <th>hd</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>63.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>145.0</td>\n",
              "      <td>233.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>150.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>2.3</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>67.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>160.0</td>\n",
              "      <td>286.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>108.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>1.5</td>\n",
              "      <td>3.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>67.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>120.0</td>\n",
              "      <td>229.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>129.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>2.6</td>\n",
              "      <td>2.0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>37.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>130.0</td>\n",
              "      <td>250.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>187.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>3.5</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>41.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>130.0</td>\n",
              "      <td>204.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>172.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-9820bf74-def7-4df9-bce5-d591edbdb258')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-9820bf74-def7-4df9-bce5-d591edbdb258 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-9820bf74-def7-4df9-bce5-d591edbdb258');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "# .head() zeigt, wie die ersten fünf Spalten in der Tabelle aussehen\n",
        "df_start.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U_i4HJhLFG3e"
      },
      "source": [
        "### 3.2 Fehlenden Daten"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "GnhhWMYbFG3e",
        "outputId": "cd5cb39c-1738-4b1e-dec6-dc16ddbd8c85",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0      0.0\n",
              "1      3.0\n",
              "2      2.0\n",
              "3      0.0\n",
              "4      0.0\n",
              "      ... \n",
              "298    0.0\n",
              "299    2.0\n",
              "300    1.0\n",
              "301    1.0\n",
              "302      ?\n",
              "Name: ca, Length: 303, dtype: object"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "# Wenn wir den Spaltennamen in eckige Klammer schreiben, z.B. ['Spaltenname'], erhalten wir die Werte dieser Spalte\n",
        "df_start['ca']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_P2AwpaFFG3e"
      },
      "source": [
        "Der letzte geplotete Wert ist ein '?'. Wir wollen kurz prüfen, ob es noch mehr solche 'speziellen' Werte gibt."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "p9n9eXJmFG3f",
        "outputId": "4f763d83-eaa6-46fe-e77f-922a9b886379",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['0.0', '3.0', '2.0', '1.0', '?'], dtype=object)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "# Die Funktion .unique() zeigt allte einzigartigen Elemente in der Spalte 'ca'\n",
        "df_start['ca'].unique()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YBGlUe3pFG3f"
      },
      "source": [
        "Da '?' der einzige 'spezielle' Werte in der Spalte ist, nehmen wir an, es sind fehlende Daten.\n",
        "\n",
        "Um zu sehen, wie viel mal dieser Wert vorkommt, filtern wir danach."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "qPUZlq3rFG3f",
        "outputId": "23abd522-d6ff-4f20-ad39-00d56467e157",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 175
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "      age  sex  restbp   chol  fbs  thalach  exang  oldpeak ca  hd\n",
              "166  52.0  1.0   138.0  223.0  0.0    169.0    0.0      0.0  ?   0\n",
              "192  43.0  1.0   132.0  247.0  1.0    143.0    1.0      0.1  ?   1\n",
              "287  58.0  1.0   125.0  220.0  0.0    144.0    0.0      0.4  ?   0\n",
              "302  38.0  1.0   138.0  175.0  0.0    173.0    0.0      0.0  ?   0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-05a776ad-7eda-4f7b-abad-710a6ca0725c\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>sex</th>\n",
              "      <th>restbp</th>\n",
              "      <th>chol</th>\n",
              "      <th>fbs</th>\n",
              "      <th>thalach</th>\n",
              "      <th>exang</th>\n",
              "      <th>oldpeak</th>\n",
              "      <th>ca</th>\n",
              "      <th>hd</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>166</th>\n",
              "      <td>52.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>138.0</td>\n",
              "      <td>223.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>169.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>?</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192</th>\n",
              "      <td>43.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>132.0</td>\n",
              "      <td>247.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>143.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>0.1</td>\n",
              "      <td>?</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>287</th>\n",
              "      <td>58.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>125.0</td>\n",
              "      <td>220.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>144.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.4</td>\n",
              "      <td>?</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>302</th>\n",
              "      <td>38.0</td>\n",
              "      <td>1.0</td>\n",
              "      <td>138.0</td>\n",
              "      <td>175.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>173.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.0</td>\n",
              "      <td>?</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-05a776ad-7eda-4f7b-abad-710a6ca0725c')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-05a776ad-7eda-4f7b-abad-710a6ca0725c button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-05a776ad-7eda-4f7b-abad-710a6ca0725c');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "# [Tabellenname['Spaltenname'] == 'zu prüfender Text'] so kann eine Tabelle nach einem spezifischen Spaltenwert gefiltert werden\n",
        "df_start[df_start['ca'] == '?']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VMJ3LM8fFG3f"
      },
      "source": [
        "Der Wert '?' kommt nur wenige Male vor. Aus diesem Grund entfernen wir jede Beobachtung mit einem Fragezeichn. Fehlende Daten können zu Fehleren in der Konstruktion von Entscheidungsbäumen führen."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MukS1onkFG3f"
      },
      "source": [
        "> **INFO:** <br>\n",
        "> Die wichtigsten Vergleichsoperatoren:\n",
        ">   \n",
        "> * ==: zu vergleichendes Element muss den gleichen Inhalt haben\n",
        "> * !=: zu vergleichendes Element darf nicht den gleichen Inhalt haben\n",
        "> * \\>=: zu vergleichende Zahl muss gleich grösser sein\n",
        "> * <=: zu vergleichende Zahl muss gleich kleiner sein"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WMmYD5ogFG3f"
      },
      "source": [
        "> **AUFGABE 3:** <br>\n",
        "> Wir haben gesehen, dass nur 4 Beobachtungen (bzw. Personen) in der Spalte 'ca' ein '?' enthalten. Weil es nur so wenige Personen sind, wollen wir diese aus unserer 'df_start' Tabelle rausfiltern und die neue Tabelle unter 'df_no_missing' speichern.\n",
        "> \n",
        "> -> Lösungen zu [Aufgabe 3](#lösung_aufgabe_3)<br>\n",
        "> -> Falls du keine Lösung findest, kopiere die Lösung aus dem Link"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "Z6gPb6jHFG3g"
      },
      "outputs": [],
      "source": [
        "# Eigene Lösung:\n",
        "df_no_missing = df_start[df_start['ca'] != '?']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "D2t1vGB9FG3g",
        "outputId": "261b9441-b01a-405a-bc5f-bee4845ff00e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['0.0', '3.0', '2.0', '1.0'], dtype=object)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "# hier prüfen wir, ob wir alle '?' entfernt haben\n",
        "df_no_missing['ca'].unique()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eAY54qgTFG3g"
      },
      "source": [
        "### 3.3 Ausreisser\n",
        "\n",
        "Boxplots zeigen, wie die Daten verteilt sind. Boxplots sind eine gute Möglichkeit Daten auf Ausreisser zu testen (Outliers). Wir zeigen dies anhand von folgendem Feature:\n",
        "* age\n",
        "\n",
        "![alt text for screen readers](./pictures/boxplot-new.png \"Beispiel Boxplot\")."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "Qs7nDQGPFG3g",
        "outputId": "ddec1170-9733-493e-ca5b-318f87daafb1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# .boxplot(Spaltenname) plottet einen Boxplot einer Tabellenspalte\n",
        "df_no_missing.boxplot('age')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gV4whmmQFG3g"
      },
      "source": [
        "Wir sehen, dass es im Feature ```age``` keine Ausreisser hat. Falls Ausreisser vorkommen, sollte man diese entfernen."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IWV1x2BRFG3g"
      },
      "source": [
        "### 3.4 Daten formatieren\n",
        "In einem nächsten Schritt müssen wir die Daten zweiteilen. Alle Features kommen in die Tabelle ```X```. Die Werte der Zielvariablen kommen in die Tabelle ```y```.\n",
        "\n",
        "```X``` stellt potentielle Beobachtungen (Daten von Personen) dar und ```y``` steht für die potentiellen Klassifizierungen (```0```=```keine HD```; ```1```=```hat HD```).\n",
        "\n",
        "Das Ziel wird es später sein, einen Entscheidungsbaum zu konstruieren welcher ```y``` möglichst richtig klassifiziert in Abhängigkeit von ```X```."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8TqJuFucFG3g"
      },
      "outputs": [],
      "source": [
        "# mit .copy() kopieren wir eine Variable in eine neue Variable\n",
        "df_clean = df_no_missing.copy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3Uo67bxgFG3q"
      },
      "outputs": [],
      "source": [
        "# in diesem Schritt speichern wir alle Features in 'X'\n",
        "# .drop('Spaltenname', axis=1) kann verwendet werden um eine Spalte zu entfernen\n",
        "# mit .copy() kopieren wir das Resultat in eine neue Variable\n",
        "X = df_clean.drop('hd', axis=1).copy()\n",
        "X.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wCriMrkYFG3q"
      },
      "outputs": [],
      "source": [
        "# in diesem Schritt speichern wir alle Zielvariablen in 'y'\n",
        "y = df_clean['hd'].copy()\n",
        "y.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NS4ewfr6FG3r"
      },
      "source": [
        "Im nächsten Schritt unterteilen wir unsere Daten in ein ```Trainings-``` und in ein ```Testset```:\n",
        "- ```Trainingsset```: Wird verwendet, um einen Entscheidungsbaum abhängig von spezifische Beobachtungen zu konstruieren (bzw. trainieren) und ihm die spezifischen Eigenschaften eines Datensatzes mit Beobachtungen beizubringen\n",
        "- ```Testset```: Wird verwendet, um den Entscheidungsbaum zu testen und zu kontrollieren, wie gut er neue Beobachtungen klassifizieren kann."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JhVMcxZlFG3r"
      },
      "outputs": [],
      "source": [
        "# train_test_split(X, y) teilt die Daten in ein Trainings- und in ein Testset\n",
        "# Standardmäßig sind im Testset 25% der Daten vorhanden und im Trainingsset 75%\n",
        "# wir sehen, dass train_test_split() 4 Tabellen generiert (je ein X und y Tabelle für beide Sets)\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UXs6XRcFFG3r"
      },
      "source": [
        "<a name=\"fourth-bullet\"></a>\n",
        "## 4 Einfacher Entscheidungsbaum (8 min)\n",
        "### 4.1 Einfacher Entscheidungsbaum"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rMeHaim9FG3r"
      },
      "source": [
        "In diesem Abschnitt konstruieren wir einen ```einfachen Entscheidungsbaum``` (ohne Optimierungen) abhängig von unseren Beobachtungen im Trainingsset.\n",
        "\n",
        "Im nächsten Abschnitt konstruieren wir einen ```opitmierten Entscheidungsbaum``` abhängig von unseren Beobachtungen im Trainingsset und vergleichen diesern mit dem ```einfachen Entscheidungsbaum```."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IBSRgDLAFG3r"
      },
      "outputs": [],
      "source": [
        "# DecisionTressClassifier() übernimmt für uns das erstellen eines Entscheidungsbaumes\n",
        "clf_dt_e = DecisionTreeClassifier(random_state=42)\n",
        "# .fit(X_train, y_train) weist dem Entscheidungsbaum ein Trainingsset (X und y) zu\n",
        "clf_dt_e.fit(X_train, y_train)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nJkaIl68FG3r"
      },
      "source": [
        "```clf_dt_e``` steht für unseren ```einfachen Entscheidungsbaum```."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": false,
        "id": "jUyPbeJ2FG3s"
      },
      "outputs": [],
      "source": [
        "# mit den folgenden Zeilen können wir einen Entscheidungsbaum plotten\n",
        "# hier wird die grösse des plotts definiert (15 steht für die Breite und 7.5 steht für die Höhe)\n",
        "plt.figure(figsize=(15, 7.5))\n",
        "\n",
        "# plot_tree(decision_tree, class_names, feature_names) übernimmt das visualisieren eines Entscheidungsbaumes für uns\n",
        "# 'decision_tree' steht für den Entscheidungsbaum der visualisiert werden soll\n",
        "plot_tree(decision_tree=clf_dt_e,\n",
        "          # 'filled=True' so werden die Knoten mit Farben gefüllt\n",
        "          filled=True,\n",
        "          # 'class_names=[\"kein HD\", \"hat HD\"]' Klassen die in jedem Knoten unter 'class' stehen sollen\n",
        "          class_names=[\"keine HD\", \"hat HD\"],\n",
        "          # 'feature_names=X.columns' muss mitgegeben werden, dass die Features im Plot korrekt bezeichnet werden\n",
        "          feature_names=X.columns)\n",
        "\n",
        "# plt.show() zeigt den Plot auf dem Bildschirm an\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ir0XhG2iFG3s"
      },
      "source": [
        "In einem ersten Schritt haben wir einen Entscheidungsbaum gebaut. Jetzt wollen wir sehen, wie gut dieser Entscheidungsbaum, welchen wir mit den Trainingsset trainiert haben, Klassifizierungen im Testset vornehmen kann."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kX3YhBRhFG3s"
      },
      "outputs": [],
      "source": [
        "# .predict(Tabellenname) kann für Klassifizierungen gebraucht werden\n",
        "# als Input muss dieser Funktion ein Tabellenname mitgegeben werden -> die Tabelle muss die Test-Features enthalten\n",
        "predictions = clf_dt_e.predict(X_test)\n",
        "# der Output ist eine Liste mit den Klassifizierungen (0=keine HD; 1=hat HD)\n",
        "predictions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OBI6-G4XFG3s"
      },
      "source": [
        "In einem nächsten Schritt wollen wir prüfen, ob diese Klassifizierungen richtig oder falsch sind."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dhpxzIlFFG3s"
      },
      "outputs": [],
      "source": [
        "# confusion_matrix(y_true, y_pred, labels) bietet uns eine Möglichkeit für so eine Prüfung\n",
        "# 'y_true' -> Liste der korrekten Klassifizierungen\n",
        "cm = confusion_matrix(y_true=y_test,\n",
        "                      # 'y_pred' -> Liste der vogenommenen Klassifizierungen\n",
        "                      y_pred=predictions,\n",
        "                      # 'labels' -> Klassen von clf_dt mitgeben\n",
        "                      labels=clf_dt_e.classes_)\n",
        "\n",
        "# ConfusionMatrixDisplay(confusion_matrix, display_labels) ist eine Möglichkeit die Confusion-Matrix 'cm' zu visualisieren\n",
        "# 'confusion_matrix' -> Confusion-Matrix die visualisiert werden soll\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=cm,\n",
        "                              # 'display_labels' -> welche Labels sollen auf der Visualisierung dargestellt werden\n",
        "                              display_labels=['keine HD', 'hat HD'])\n",
        "# .plot() plotet die Visualisierung\n",
        "disp.plot()\n",
        "# plt.show() zeigt den Plot auf dem Bildschirm an\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ibcYOT8HFG3t"
      },
      "source": [
        "Die oben abgebildete Grafik zeigt eine ```Confusion-Matrix```. Wie lesen wir diese:\n",
        "- 31: Haben keine Herzkrankheit -> Diese 31 haben wir korrekt klassifiziert (True Negative TN) <br>\n",
        "- 12: Haben keine Herzkrankheit -> Diese 12 haben wir falsch klassifiziert (False Negative FN) <br>\n",
        "- 25: Haben eine Herzkrankheit -> Diese 25 haben wir korrekt klassifiziert (True Positive TP) <br>\n",
        "- 7: Haben eine Herzkrankheit -> Diese 7 haben wir falsch klassifiziert (False Positive FP)\n",
        "\n",
        "Wie gut ein Entscheidungsbaum ist, definieren wir anhand der ```Accuracy```. Welche mit Hilfe der ```Confusion-Matrix``` berechnet werden kann."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r6Gj-M1qFG3t"
      },
      "source": [
        "> **INFO:**\n",
        "> \n",
        "> Accuracy = (TP + TN) / (TP + TN + FP + FN)\n",
        "> <br>\n",
        "> <br>... bei unserem einfachen Entscheidungsbaum haben wir z.B. folgende Accuracy:\n",
        "> <br> \n",
        "> <br>Accuracy = (25 + 31) / (25 + 31 + 7 + 12) = 0.75"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xWokon4IFG3t"
      },
      "outputs": [],
      "source": [
        "# accuracy_score(y_true, y_pred) liefert ebenfalls die korrekte Accuracy\n",
        "accuracy_score(y_true=y_test,\n",
        "               y_pred=predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LqTjAW8cFG3t"
      },
      "source": [
        "<a name=\"fifth-bullet\"></a>\n",
        "## 5 Optimierter Entscheidungsbaum (12 min)\n",
        "### 5.1 Pruning"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLHGP1I4FG3t"
      },
      "source": [
        "![alt text for screen readers](./pictures/ccp.png \"Pruning\")."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X4yPPe5QFG3t"
      },
      "source": [
        "Wir haben einen ```einfachen Entscheidungsbaum``` konstruiert. Dieser Entscheidungsbaum ist auf unser Trainigsset überangepasst. Das heisst, er funktioniert sehr gut für die Klassifizierung von Beobachtungen aus unserem Trainigsset aber weniger gut für die Klassifizierung von neuen Beobachtungen.\n",
        "\n",
        "Dieses Problem können wir lösen, indem wir verschiedene Arten von Parametern verwenden (z. B. ```max_ Depth``` oder ```min_samples```) und den Entscheidungsbaum optimieren bzw. vereinfachen (weniger Blätter). Diesen Prozess nennt man ```Pruning```.\n",
        "\n",
        "```Pruning``` sollte die ```Accuracy``` im Bezug auf neue Beobachtungen verbessern.\n",
        "\n",
        "```Cost Complexity Pruning``` ist eine spezifische Methode, um einen kleineren Baum zu finden, der bessere Ergebnisse mit neuen Beobachtungen liefert. Wir schauen, ob kleinere Teil-Entscheidungsbäume (Baum mit 38 Blätter, Baum mit 37 Blätter, etc.) bessere Ergebnisse liefern als grössere. Damit kleinere Bäume mit grösseren Bäumen verglichen werden können, verwenden wir ```alpha``` als eine Art Penalty, der das Ergebniss von kleineren Bäumen verbessert (Überanpassung kontra. Genauigkeit im Trainingsdatenset).\n",
        "\n",
        "Eine genauere Anleitung zum ```Cross Complexity Pruning``` findet ihr [hier](#anhang_1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DhpUL-IVFG3u"
      },
      "source": [
        "> **INFO:**\n",
        "> \n",
        "> Die Werte von ```alpha``` sind wie folgt zu interpretieren:\n",
        "> - 0: Der Entscheidungsbaum ist nicht geprunt (maximale Grösse)\n",
        "> - je grösser ```alpha``` desto einfacher (weniger Blätter) ist der Entscheidungsbaum"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-tBQk8MvFG3u"
      },
      "outputs": [],
      "source": [
        "# .cost_complexity_pruning_path(X_train, y_train) ist ein Algorithmus\n",
        "# der als Ergebniss wichtige 'alpha' Parameter liefert, welche es zu Überprüfen gilt\n",
        "path = clf_dt_e.cost_complexity_pruning_path(X_train, y_train)\n",
        "ccp_alphas = path.ccp_alphas\n",
        "ccp_alphas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xIfTuDB4FG3u"
      },
      "outputs": [],
      "source": [
        "# wir konstruieren jetzt einen Tree mit 'alpha' = 0.00541298\n",
        "value_alpha = 0.00541298\n",
        "\n",
        "# definiere den Entscheidungsbaum\n",
        "clf_dt_new = DecisionTreeClassifier(random_state=0,\n",
        "                                    ccp_alpha=value_alpha)\n",
        "clf_dt_new.fit(X_train, y_train)\n",
        "\n",
        "# plote den Entscheidungsbaum\n",
        "plot_tree(decision_tree=clf_dt_new,\n",
        "          filled=True,\n",
        "          class_names=[\"keine HD\", \"hat HD\"],\n",
        "          feature_names=X.columns)\n",
        "\n",
        "# plt.show() zeigt den Plot auf dem Bildschirm an\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nrk_grM5FG3u"
      },
      "source": [
        "> **AUFGABE 4:** <br>\n",
        ">\n",
        "> Kontruiere und plote drei verschiedene Entscheidungsbäume mit verschiedenen 'alpha' Values. Für die Konstruktion kannst du den obigen Code verwenden bzw. kopieren.\n",
        "> \n",
        "> Bitte stelle sicher, dass du die Entscheidungsbäume in den folgenden Variablen abspeicherst:\n",
        "> - clf_dt_1\n",
        "> - clf_dt_2\n",
        "> - clf_dt_3\n",
        ">\n",
        "> -> Lösungen zu [Aufgabe 4](#lösung_aufgabe_4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9C4R4jtQFG3u"
      },
      "outputs": [],
      "source": [
        "# Eigene Lösung:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NbOhgNSbFG3u"
      },
      "outputs": [],
      "source": [
        "# für den konstruierten Entscheidungsbaum 'clf_dt_new' wollen wir die Confusion-Matrix plotten, um zu sehen, wie gut er performt\n",
        "# Klasifizierungen\n",
        "predictions = clf_dt_new.predict(X_test)\n",
        "cm = confusion_matrix(y_true=y_test,\n",
        "                      y_pred=predictions,\n",
        "                      labels=clf_dt_new.classes_)\n",
        "\n",
        "# ploten der Confusion-Matrix\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=cm,\n",
        "                              display_labels=['keine HD', 'hat HD'])\n",
        "\n",
        "# .plot() plotet die Visualisierung\n",
        "disp.plot()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kQ-1nuPbFG3v"
      },
      "source": [
        "> **AUFGABE 5:**\n",
        "> \n",
        "> Plote die Confusion-Matrix für die in Aufgabe 4 kosnstruierten Entscheidungsbäume. Für die Plots kannst du den obigen Code verwenden bzw. kopieren.\n",
        "> <br>\n",
        "> <br>-> Lösungen zu [Aufgabe 5](#lösung_aufgabe_5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FmA8mastFG3v"
      },
      "outputs": [],
      "source": [
        "# Eigene Lösung:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ii9hsu46FG3v"
      },
      "source": [
        "Wir haben jetzt gesehen, dass je nach ```alpha``` die Ergebnisse schlechter oder besser werden. Die Frage ist jetzt, wie finden wir auf eine einfache Art dasjenige 'alpha', bei welchem die Ergebnisse am besten sind.\n",
        "\n",
        "Wir schreiben einen Code der folgendes für uns erledigt:\n",
        "1. Einen Entscheidungsbaum pro ```alpha``` Wert konstruieren\n",
        "2. Pro Entscheidungsbaum die ```Accuracy``` für das Testset und das Trainingsset rechnen\n",
        "3. Die ```Accuracy``` für jeden Entscheidungsbaum in Abhängigkeit von ```alpha``` ploten\n",
        "\n",
        "Der Code, welcher dies für uns ausführt, findet ihr untenstehend."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zxssBRYhFG3v"
      },
      "source": [
        "**Komplexe Code-Zelle:**\n",
        "```\n",
        "Die nachfolgenden Code-Zelle muss nur ausgeführt werden. Das Nachvollziehen der Funktionsweise ist nicht Teil dieser Einführung, dies würde über den Scope hinaus gehen.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LY7XYfK3FG3v"
      },
      "outputs": [],
      "source": [
        "# mit [:-1] entfernen wir den grössten 'alpha' Wert (das grösste 'alpha' hat keine Blätter)\n",
        "ccp_alphas = ccp_alphas[:-1]\n",
        "\n",
        "clf_dts = []\n",
        "\n",
        "for ccp_alpha in ccp_alphas:\n",
        "    clf_dt = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)\n",
        "    clf_dt.fit(X_train, y_train)\n",
        "    clf_dts.append(clf_dt)\n",
        "    \n",
        "# mit dem untenstehenden Code plotten wir 'Accuracy' in Abhängigkeit zu 'alpha' (für Testdaten und Trainingsdaten)\n",
        "train_scores = [clf_dt.score(X_train, y_train) for clf_dt in clf_dts]\n",
        "test_scores = [clf_dt.score(X_test, y_test) for clf_dt in clf_dts]\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "ax.set_xlabel('alpha')\n",
        "ax.set_ylabel('accuracy')\n",
        "ax.set_title('Accuracy vs alpha for training and testing sets')\n",
        "ax.plot(ccp_alphas, train_scores, marker='o', label='train', drawstyle='steps-post')\n",
        "ax.plot(ccp_alphas, test_scores, marker='o', label='test', drawstyle='steps-post')\n",
        "ax.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FXzVv3_PFG3w"
      },
      "source": [
        "Im obigen Plot finden wir die nötigen Informationen, welche wir brauchen, um das beste ```alpha``` zu finden.\n",
        "\n",
        "Von Interesse ist vor allem die orange Linie (```Testdaten```).\n",
        "\n",
        "Bei der Auswahl des besten ```alpha``` achten wir auf die folgenden zwei Punkte:\n",
        "1. Die ```Accuracy``` von ```test``` soll möglichst gross sein\n",
        "2. Die ```Accuracy``` von ```train``` soll möglichst gross sein\n",
        "\n",
        "Unter Anbetracht des aufgeführten Punktes, ist das optimale ```alpha``` also der sechsletzte Punkt auf der ```test``` Linie."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jKYUCbxjFG3w"
      },
      "outputs": [],
      "source": [
        "# um den sechsletzten Punkt zu finden rufen wir nochmals die Liste mit den 'alpha' Werten auf\n",
        "ccp_alphas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eQGPZR8yFG3w"
      },
      "outputs": [],
      "source": [
        "# optimales 'alpha'\n",
        "alpha_opt = 0.01081731"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0AQR4jRAFG3w"
      },
      "outputs": [],
      "source": [
        "# definiere den Entscheidungsbaum\n",
        "clf_dt_pruned = DecisionTreeClassifier(random_state=42,\n",
        "                                       ccp_alpha=alpha_opt)\n",
        "clf_dt_pruned = clf_dt_pruned.fit(X_train, y_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Nk_EQIiAFG3w"
      },
      "outputs": [],
      "source": [
        "# plotte den Entscheidungsbaum\n",
        "plt.figure(figsize=(15, 7.5))\n",
        "plot_tree(clf_dt_pruned,\n",
        "          filled=True,\n",
        "          class_names=[\"keine HD\", \"hat HD\"],\n",
        "          feature_names=X.columns)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7eu2x2OrFG3w"
      },
      "outputs": [],
      "source": [
        "# 'Accuracy' des neuen Entscheidungsbaumes\n",
        "predictions_new = clf_dt_pruned.predict(X_test)\n",
        "accuracy_score(y_true=y_test,\n",
        "               y_pred=predictions_new)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j01vdSqLFG3x"
      },
      "source": [
        "Wir erhalten die folgenden ```Accuracy-Werte```:\n",
        "* einfacher Entscheidungsbaum = ```0.746```\n",
        "* optimierter Entscheidungsbaum = ```0.786```\n",
        "\n",
        "Wenn wir diese beiden Werte vergleichen, sehen wir, dass wir durch die Optimierung einen Entscheidungsbaum erhalten haben, welcher besser mit neuen Beobachtungen umgehen kann."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdlFmDYLFG3x"
      },
      "source": [
        "<a name=\"sixth-bullet\"></a>\n",
        "## 6 Abschluss (4 min)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xlZHJA7vFG3x"
      },
      "source": [
        "Was haben wir gelernt:\n",
        "* Was sind Entscheidungsbäume?\n",
        "* Wie lesen wir Entscheidungsbäume?\n",
        "* Wie bereiten wir Daten auf (fehlende Daten & Ausreisser)?\n",
        "* Arbeiten mit Trainings- und Testset\n",
        "* Erstellen von einfachen Entscheidungsbäumen\n",
        "* Optimieren von einfachen Entscheidungsbäumen\n",
        "* Accuracy und Confusion-Matrix\n",
        "\n",
        "Was muss man beachten, wenn man Modelle integrieren will:\n",
        "* Generalisierung\n",
        "* Software-Engineering-Skills um Modelle in Applikationen einzubinden\n",
        "* Antwortzeiten\n",
        "* Monitoren der Vorhersagequalität\n",
        "* Zusammenarbeit von mehreren Rollen (Data-Engineer, Data-Scientist, Software-Engineer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a7HtcE_mFG3x"
      },
      "source": [
        "<a name=\"seventh-bullet\"></a>\n",
        "## 7 Anhang"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lGrMAdYVFG3x"
      },
      "source": [
        "<a id='anhang_1'></a>\n",
        "### Anhang 1: Anleitung Cross Complexity Pruning\n",
        "\n",
        "Der Algorithmus zur Kostenkomplexitätsbeschneidung folgt in der Regel diesen Schritten:\n",
        "\n",
        "1. Erstelle einen anfänglichen Entscheidungsbaum mit einem Trainingsdatensatz unter Berücksichtigung aller verfügbaren Attribute und Merkmale.\n",
        "2. Bewerte die Klassifikationsleistung des Entscheidungsbaums anhand eines separaten Validierungsdatensatzes.\n",
        "3. Berechne für jeden internen Knoten des Entscheidungsbaums seine potenziellen Kosten in Bezug auf die fehlerhafte Klassifizierung oder andere Metriken.\n",
        "4. Weise jedem internen Knoten eine Kostenkomplexitätswertung zu, die in der Regel als Summe seiner Kosten für fehlerhafte Klassifizierung und eines Strafterms berechnet wird, der proportional zur Anzahl der absteigenden Blattknoten ist.\n",
        "5. Beginnend beim Wurzelknoten beschneide iterativ den Knoten mit der niedrigsten Kostenkomplexitätswertung und erstellen eine Reihe von kleineren Entscheidungsbäumen.\n",
        "6. Bewerte die Klassifikationsleistung jedes beschnittenen Entscheidungsbaums anhand des Validierungsdatensatzes.\n",
        "7. Wähle den beschnittenen Baum mit der besten Leistung aus, die oft anhand der Genauigkeit oder einer anderen geeigneten Metrik gemessen wird.\n",
        "8. Optional kann man den ausgewählten Baum weiter beschneiden, indem man den Komplexitätsparameter α optimiert und die Schritte 5-7 wiederholt.\n",
        "9. Der endgültige beschnittene Entscheidungsbaum wird erzielt, wenn durch zusätzliches Beschneiden keine weiteren Verbesserungen der Leistung erzielt werden können."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZSmqGQEbFG3y"
      },
      "source": [
        "<a name=\"eight-bullet\"></a>\n",
        "## 8 Lösungen"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V7eI-xQiFG3y"
      },
      "source": [
        "<a name='lösung_aufgabe_1'></a>\n",
        "### Lösung Aufgabe 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hTw99qKdFG3y"
      },
      "outputs": [],
      "source": [
        "# Person 1 = 'Has Insurance'\n",
        "# Person 2 = 'Has Insurance' "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zwnYVwVFG3z"
      },
      "source": [
        "![alt text for screen readers](./pictures/Lösung_mit_Pfaden.png \"Lösung\")."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f82cx6YRFG3z"
      },
      "source": [
        "<a name='lösung_aufgabe_2'></a>\n",
        "### Lösung Aufgabe 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v2PtlpcmFG3z"
      },
      "outputs": [],
      "source": [
        "df_start = df"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C0RepRk_FG3z"
      },
      "source": [
        "<a name='lösung_aufgabe_3'></a>\n",
        "### Lösung Aufgabe 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l5U8U1dSFG3z"
      },
      "outputs": [],
      "source": [
        "df_no_missing = df_start[df_start['ca'] != '?']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a68Qk5VjFG3z"
      },
      "source": [
        "<a name='lösung_aufgabe_4'></a>\n",
        "### Lösung  Aufgabe 4\n",
        "\n",
        "Die folgenden Code-Zellen bilden eine mögliche Lösung zu Aufgabe 4 ab."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oSTkNsQEFG30"
      },
      "outputs": [],
      "source": [
        "# wir konstruieren jetzt einen Tree mit 'alpha' = 0.00557903\n",
        "value_alpha = 0.0000000000001\n",
        "\n",
        "# definiere den Entscheidungsbaum\n",
        "clf_dt_1 = DecisionTreeClassifier(random_state=0,\n",
        "                                ccp_alpha=value_alpha)\n",
        "clf_dt_1.fit(X_train, y_train)\n",
        "\n",
        "# plote den Entscheidungsbaum\n",
        "plot_tree(decision_tree=clf_dt_1,\n",
        "          filled=True,\n",
        "          class_names=[\"keine HD\", \"hat HD\"],\n",
        "          feature_names=X.columns)\n",
        "\n",
        "# plt.show() zeigt den Plot auf dem Bildschirm an\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I3dDg6OGFG30"
      },
      "outputs": [],
      "source": [
        "# wir konstruieren jetzt einen Tree mit 'alpha' = 0.00557903\n",
        "value_alpha = 0.01425422\n",
        "\n",
        "# definiere den Entscheidungsbaum\n",
        "clf_dt_2 = DecisionTreeClassifier(random_state=0,\n",
        "                                ccp_alpha=value_alpha)\n",
        "clf_dt_2.fit(X_train, y_train)\n",
        "\n",
        "# plote den Entscheidungsbaum\n",
        "plot_tree(decision_tree=clf_dt_2,\n",
        "          filled=True,\n",
        "          class_names=[\"keine HD\", \"hat HD\"],\n",
        "          feature_names=X.columns)\n",
        "\n",
        "# plt.show() zeigt den Plot auf dem Bildschirm an\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9iAI-NM3FG30"
      },
      "outputs": [],
      "source": [
        "# wir konstruieren jetzt einen Tree mit 'alpha' = 0.00557903\n",
        "value_alpha = 0.2\n",
        "\n",
        "# definiere den Entscheidungsbaum\n",
        "clf_dt_3 = DecisionTreeClassifier(random_state=0,\n",
        "                                ccp_alpha=value_alpha)\n",
        "clf_dt_3.fit(X_train, y_train)\n",
        "\n",
        "# plote den Entscheidungsbaum\n",
        "plot_tree(decision_tree=clf_dt_3,\n",
        "          filled=True,\n",
        "          class_names=[\"keine HD\", \"hat HD\"],\n",
        "          feature_names=X.columns)\n",
        "\n",
        "# plt.show() zeigt den Plot auf dem Bildschirm an\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lhss09q0FG30"
      },
      "source": [
        "<a name='lösung_aufgabe_5'></a>\n",
        "### Lösung  Aufgabe 5\n",
        "Die folgenden Code-Zellen bilden eine mögliche Lösung zu Aufgabe 5 ab."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sqHVnRY-FG30"
      },
      "outputs": [],
      "source": [
        "# Klasifizierungen\n",
        "predictions = clf_dt_1.predict(X_test)\n",
        "cm = confusion_matrix(y_true=y_test,\n",
        "                      y_pred=predictions,\n",
        "                      labels=clf_dt_1.classes_)\n",
        "\n",
        "# ploten der Confusion-Matrix\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=cm,\n",
        "                              display_labels=[\"keine HD\", \"hat HD\"])\n",
        "\n",
        "# .plot() plotet die Visualisierung\n",
        "disp.plot()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RaaaDSz0FG31"
      },
      "outputs": [],
      "source": [
        "# Klasifizierungen\n",
        "predictions = clf_dt_2.predict(X_test)\n",
        "cm = confusion_matrix(y_true=y_test,\n",
        "                      y_pred=predictions,\n",
        "                      labels=clf_dt_2.classes_)\n",
        "\n",
        "# ploten der Confusion-Matrix\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=cm,\n",
        "                              display_labels=[\"keine HD\", \"hat HD\"])\n",
        "\n",
        "# .plot() plotet die Visualisierung\n",
        "disp.plot()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vKFRDgfTFG31"
      },
      "outputs": [],
      "source": [
        "# Klasifizierungen\n",
        "predictions = clf_dt_3.predict(X_test)\n",
        "cm = confusion_matrix(y_true=y_test,\n",
        "                      y_pred=predictions,\n",
        "                      labels=clf_dt_3.classes_)\n",
        "\n",
        "# ploten der Confusion-Matrix\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=cm,\n",
        "                              display_labels=[\"keine HD\", \"hat HD\"])\n",
        "\n",
        "# .plot() plotet die Visualisierung\n",
        "disp.plot()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ha-ceeEBFG31"
      },
      "source": [
        "<a name=\"nineth-bullet\"></a>\n",
        "## 9 Quellen"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5pbBGXt6FG31"
      },
      "source": [
        "### &#169; Quellen:\n",
        "&#128190; **Daten:** https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/\n",
        "<br>\n",
        "&#128252;  **Video:** https://youtu.be/q90UDEgYqeI?list=PLBq2sVJiEBvA9rPo3IEQsJNI4IJbn81tB\n",
        "\n",
        "### &#128161; Weitere Informationen:\n",
        "\n",
        "``` Decision Trees: ``` &nbsp; https://www.youtube.com/watch?v=7VeUPuFGJHk&t=0s\n",
        "<br>\n",
        "``` Cross Validation: ``` &nbsp; https://www.youtube.com/watch?v=fSytzGwwBVw&t=0s\n",
        "<br>\n",
        "``` Confusion Matrix: ``` &nbsp; https://www.youtube.com/watch?v=Kdsp6soqA7o&t=0s\n",
        "<br>\n",
        "``` Cost-Complexity Pruning: ``` &nbsp; https://www.youtube.com/watch?v=D0efHEJsfHo&t=0s\n",
        "<br>\n",
        "``` Bias and Variance and Overfitting: ``` &nbsp; https://www.youtube.com/watch?v=EuBBz3bI-aA&t=0s"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.9"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": true,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {},
      "toc_section_display": true,
      "toc_window_display": false
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}