4_NeuronalesNetzwerk.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Das neuronale Netzwerk trainieren und testen\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt kommen wir endlich zum Herzstück des Projekts: Das neuronale Netzwerk. Genauer: Ein Multi-Layer-Perzeptron-Klassifikator. Allgemeinere Dokumentation für diese Art von Maschinellem Lernen mit Scikit-learn findet sich [hier](https://scikit-learn.org/stable/modules/neural_networks_supervised.html).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier kommt wieder eine neue Library ins Spiel:\n",
    "[`Scikit-learn`](https://de.wikipedia.org/wiki/Scikit-learn) (ehemals scikits.learn) ist eine Bibliothek zum maschinellen Lernen.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix, f1_score\n",
    "from sklearn.metrics import precision_recall_fscore_support as score\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "mode = 1\n",
    "# 1 = Nationalratswahlen\n",
    "# 2 = Ständeratswahlen\n",
    "\n",
    "filename_csv_all = \"nationalrat_all.csv\" if mode == 1 else \"ständerat_all.csv\"\n",
    "filename_csv_train = \"nationalrat_train.csv\" if mode == 1 else \"ständerat_train.csv\"\n",
    "filename_csv_test = \"nationalrat_test.csv\" if mode == 1 else \"ständerat_test.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Als erstes müssen die Trainingsdaten in Inputs und Labels aufgeteilt werden. Die Inputs sind in diesem Fall die Antworten zwischen 0 und 1 und die Labels sind die Parteien. Das Netzwerk soll dann lernen, in den Inputs - also den Antworten - Muster zu finden die auf die Labels - also die Parteien - schliessen lassen.\n",
    "\n",
    "Vielleicht haben Sie schon bemerkt, dass die Parteinamen aktuell noch Text sind. Eigentlich müssten sie deshalb noch in Zahlen umgewandelt werden. [`Scikit-learn`](https://de.wikipedia.org/wiki/Scikit-learn) macht das jedoch automatisch.\n",
    "\n",
    "---\n",
    "\n",
    "> **Für die Interessierten**\n",
    ">\n",
    "> Eine Möglichkeit wäre, jeder Partei eine Zahl zuzuweisen, also zB. `Piratenpartei=0, SP=0.1, Grüne=0.2, ...`, jedoch macht das aus mathematischer Sicht keinen Sinn, da die Parteien keine intrinsische Reihenfolge haben. Besser ist es, jeder kandidierenden Person einen Eintrag für jede Partei zu erstellen. Dieser Eintrag ist `0`, wenn die Person nicht in der Partei ist und `1`, wenn sie es ist. Da jede Person in genau einer Partei ist (zumindest nach Datensatz von Smartvote), hat jede Person genau eine Eins unter vielen Nullen, deshalb wird diese Art von Liste - auf mathematisch Vektor - One-Hot-Vector oder zu Deutsch\n",
    "> [1-aus-n-Code](https://de.wikipedia.org/wiki/1-aus-n-Code) genannt, wobei n in diesem Fall für die Anzahl Parteien steht.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def csv_to_vectors(filename):\n",
    "    training_df = pd.read_csv(filename)\n",
    "\n",
    "    input_columns = [str(q) for q in range(32214, 32289)]\n",
    "    input_columns.append(\"gender\")\n",
    "\n",
    "    inputs = training_df[input_columns]\n",
    "    labels = training_df[[\"partyAbbreviation\"]]\n",
    "\n",
    "    return inputs, labels\n",
    "\n",
    "\n",
    "training_inputs, training_labels = csv_to_vectors(filename_csv_train)\n",
    "\n",
    "training_inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt kann endlich das Netzwerk trainiert werden. Wir verwenden ein [Multi-Layer-Perzeptron](https://de.wikipedia.org/wiki/Multi-Layer-Perzeptron) als Modell. Mit den Parametern und besonders den `hidden_layer_sizes` musste experimentiert werden, bis die Genauigkeit zufriedenstellend war.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MLPClassifier(\n",
    "    solver=\"adam\",\n",
    "    hidden_layer_sizes=(20, 30),\n",
    "    activation=\"relu\",\n",
    "    verbose=True,\n",
    "    max_iter=1000,\n",
    "    tol=0.000001,\n",
    ")\n",
    "\n",
    "# Alle Parteien, die klassifizierbar sein sollen\n",
    "parties = np.array(list(set(pd.read_csv(filename_csv_all)[\"partyAbbreviation\"])))\n",
    "model.classes_ = parties\n",
    "\n",
    "# fit = trainieren\n",
    "model.fit(training_inputs, training_labels.to_numpy().ravel())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testen wir doch gleich noch die Genauigkeit. Es ist beim Testen wichtig, dass keine Daten verwendet werden, die das Modell beim Trainieren schon gesehen hat.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_inputs, test_labels = csv_to_vectors(filename_csv_test)\n",
    "\n",
    "model.score(test_inputs, test_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "~0.6 = 60%\n",
    "\n",
    "Das heisst, dass etwa 60% der Kandidierenden zur richtigen Partei zugeordnet wurden!\n",
    "\n",
    "Welche Parteien wurden denn verwechselt?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_predictions = model.predict(test_inputs)\n",
    "\n",
    "# Parteien nach F1-Score sortieren\n",
    "parties = [\n",
    "    party[0]\n",
    "    for party in sorted(\n",
    "        zip(\n",
    "            parties,\n",
    "            f1_score(test_labels, test_predictions, average=None, labels=parties),\n",
    "        ),\n",
    "        key=lambda party: party[1],\n",
    "        reverse=True,\n",
    "    )\n",
    "]\n",
    "\n",
    "\n",
    "cm = confusion_matrix(test_labels, test_predictions, labels=parties, normalize=\"pred\")\n",
    "\n",
    "plt.figure(dpi=300)\n",
    "sns.set_theme(font_scale=0.3)\n",
    "ax = plt.subplot()\n",
    "\n",
    "\n",
    "sns.heatmap(cm, annot=True, ax=ax, cmap=\"Blues\", fmt=\".0%\", vmax=np.max(cm))\n",
    "\n",
    "\n",
    "ax.set_xlabel(\"Vorhergesagte Partei\")\n",
    "ax.set_ylabel(\"Tatsächliche Partei\")\n",
    "plt.xticks(rotation=45)\n",
    "plt.yticks(rotation=45)\n",
    "ax.set_title(\"Confusion Matrix\")\n",
    "ax.xaxis.set_ticklabels(parties, rotation_mode=\"anchor\", ha=\"right\", va=\"center\")\n",
    "ax.yaxis.set_ticklabels(parties, rotation_mode=\"anchor\", ha=\"right\", va=\"center\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Diagonale steht für die richtig vorhergesagten Parteien, alle anderen Verfärbungen sind Verwechslungen. Man kann erkennen, dass viele Verwechslungen zwischen Parteien mit ähnlichen Agenden stattfinden. So werden Jungparteien oftmals mit ihren Mutterparteien verwechselt. Man kann auch andere spannende Dinge beobachten. So gibt es Parteien, die kaum mit anderen verwechselt werden - z.B. die SP und die Partei der Arbeit - und es gibt solche die sehr oft mit anderen verwechselt werden - z.B. die EVP und die Piratenpartei. Vielleicht könnten wir versuchen, das zu formalisieren.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "precision, recall, fscore, support = score(\n",
    "    test_labels, test_predictions, labels=parties, zero_division=0\n",
    ")\n",
    "\n",
    "df = pd.DataFrame([parties, precision, recall, fscore, support]).T\n",
    "\n",
    "df.rename(\n",
    "    columns={0: \"Partei\", 1: \"Präzision\", 2: \"Recall\", 3: \"F1-Score\", 4: \"Vorkommen\"},\n",
    "    inplace=True,\n",
    ")\n",
    "\n",
    "df = df.sort_values(\"F1-Score\", ascending=False)\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der sogenannte [F1-Score](https://databasecamp.de/statistik/f1-score) ist das harmonische Mittel von Präzision und Recall. Er stellt in diesem Fall in etwa dar, wie häufig eine Partei **nicht** verwechselt wurde. Man kann also erkennen, dass die Parteien tatsächlich sehr unterschiedlich oft richtig erkannt werden. Es scheint, also ob Parteien mit eher radikalen Agenden am häufigsten richtig erkannt werden und Jungparteien am seltensten. Die Mitte könnte so hoch auf der Rangliste sein, weil sie die meisten Kandidierenden hat, das Netzwerk also viele Beispiele gesehen hat.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "parlamentarier-UYno04rm",
   "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}