added stuff

05_ML/code/ml_basics_1.ipynb

@@ -0,0 +1,498 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div style=\"\n",
+    "    border: 2px solid #4CAF50; \n",
+    "    padding: 15px; \n",
+    "    background-color: #f4f4f4; \n",
+    "    border-radius: 10px; \n",
+    "    align-items: center;\">\n",
+    "\n",
+    "<h1 style=\"margin: 0; color: #4CAF50;\">ML Basics 1: Die Grundlagen</h1>\n",
+    "<h2 style=\"margin: 5px 0; color: #555;\">DSAI</h2>\n",
+    "<h3 style=\"margin: 5px 0; color: #555;\">Jakob Eggl</h3>\n",
+    "\n",
+    "<div style=\"flex-shrink: 0;\">\n",
+    "    <img src=\"https://www.htl-grieskirchen.at/wp/wp-content/uploads/2022/11/logo_bildschirm-1024x503.png\" alt=\"Logo\" style=\"width: 250px; height: auto;\"/>\n",
+    "</div>\n",
+    "<p1> © 2024/25 Jakob Eggl. Nutzung oder Verbreitung nur mit ausdrücklicher Genehmigung des Autors.</p1>\n",
+    "</div>\n",
+    "<div style=\"flex: 1;\">\n",
+    "</div>   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In diesem Notebook werden wir beginnen, im allgemeinen Machine Learning Process die nächsten Punkte zu erklären. Insbesondere wollen wir anfangen zu verstehen, wie (Machine Learning) Modelle aussehen und wie sie funktionieren."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Der ML-Process"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![ML Process](../resources/1_ML_Process.png)\n",
+    "\n",
+    "(von AI Inside Seminar KI Mag. Otto Reichel)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Was haben wir **bisher** gemacht:\n",
+    "* Daten Akquisition:\n",
+    "    * Wie sammle ich meine Daten?\n",
+    "    * Umfragen, Logging, Scraping\n",
+    "* Daten Bereinigung:\n",
+    "    * Normalisieren\n",
+    "    * Fehlende Werte behandeln"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nun sehen wir uns die **Grundlagen** zu den Punkten\n",
+    "* Model Training\n",
+    "* Train/Test Daten\n",
+    "* Model Tests\n",
+    "* Model Einsatz"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Wichtig**: Machine Learning Process ist, wie im Bild gezeigt, ein sehr interaktiver Vorgang.\n",
+    "\n",
+    "Machine Learning ist also nicht immer zwingend genau ein konkreter Vorgang: Es spielen immer viele Dinge zusammen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Unterschied zur normalen Informatik:\n",
+    "* Wir lernen von Daten; **NUR** von Daten!\n",
+    "\n",
+    "![AI vs CS](../resources/1_AI_vs_CS.png)\n",
+    "\n",
+    "(von https://www.linkedin.com/pulse/machine-learning-vs-classical-ai-muhammad-imran-arshad-6anlf/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wir unterscheiden zwischen **Supervised** und **Unsupervised** Methoden!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Supervised Machine Learning vs. Unsupervised ML Learning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Supervised Machine Learning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* In den Trainings-/Testdaten ist die vorherzusagende Große enthalten. An Hand der Eingangsdaten (Features) $X = (x_1, x_2, \\ldots, x_n)$ soll die gekennzeichnete Große $y$ (Label) vorhergesagt werden. **Wichtig**: Das Label kann sowohl eine Zahl sein, als auch eine Klasse!\n",
+    "* Zum Beispiel konnte der Preis (=Label) eines Gebrauchtwagens an Hand der Features Baujahr, PS, Marke, km-Stand, Antriebsart vorhergesagt werden.\n",
+    "* Der lernende Algorithmus erhalt beim Training Datensätze, die sowohl die Features (Eingangsdaten) als auch den korrekten Output (Label) enthalten\n",
+    "und lernt dazu, indem er den aktuellen Output des Modells mit dem korrekten Output vergleicht und versucht, den Fehler zu minimieren. In dieser Phase verbessert er das Modell iterativ.\n",
+    "* Eines der Haupteinsatzgebiete von Supervised Learning ist die Vorhersage zukunftiger Daten aus historischen Daten.\n",
+    "\n",
+    "(aus AI Inside, Seminar KI; Mag. Otto Reichel)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![Supervised ML](../resources/1_Supervised_ML.png)\n",
+    "\n",
+    "(von https://www.vproexpert.com/what-is-the-difference-between-supervised-and-unsupervised-machine-learning/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Unsupervised ML"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* In den Trainings-/Testdaten ist die vorherzusagende Größe nicht enthalten (Daten sind ohne Label - Unlabeled). An Hand der Eingangsdaten (Features) $X=(x_1, x_2, \\ldots, x_n)$ sind Gruppen zu finden, die zusammengehörige Daten repräsentieren\n",
+    "* Dem System wird in der Trainingsphase (kein echtes \"Training\", aber es wird das Model an die Daten angepasst) kein richtiges Ergebnis geliefert\n",
+    "* Das Hauptziel ist die Analyse der Daten und das Auffinden von zugrundeliegenden Mustern.\n",
+    "\n",
+    "(aus AI Inside, Seminar KI; Mag. Otto Reichel)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![Unsupervised ML](../resources/1_Unsupervised_ML.png)\n",
+    "\n",
+    "(von https://www.linkedin.com/pulse/unveiling-top-5-unsupervised-machine-learning-algorithms-yadav-0yikc/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In beiden Fällen stellt $X$ nun den Feature Vektor dar. Unser Dataset besteht dann normalerweise aus $m$ solchen Vektoren der Größe $n$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Beispiele:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Beispiel1:\n",
+    "Einem Machine Learning Modell werden immer 2 Zahlen gegeben. Dabei ist die erste Zahl das Feature und die 2. Zahl das Label.\n",
+    "Das Modell soll lernen, für neue Daten, die 2. Zahl zu erraten. Die Daten sehen dabei folgendermaßen aus:\n",
+    "$$\\{(1,1), (4, 16), (-2, 4), \\ldots, (9, 81)\\}.$$\n",
+    "\n",
+    "Welchen Zusammenhang soll das Modell hier lernen? Was soll das Modell für den Input $10$ vorhersagen?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Beispiel2:\n",
+    "Einem Machine Learning Modell wird immer eine Integer Zahl und ein Bit ($0$ oder $1$) gegeben. Das Model soll lernen, welche Zahlen das Bit $1$ und welche Zahlen das Bit $0$ bekommen.\n",
+    "Die Daten sehen so aus:\n",
+    "$$\\{(1,0), (4,1), (8, 1), (9,0), (10,1), \\ldots, (-4, 1)\\}.$$\n",
+    "\n",
+    "Welcher Zusammenhang wurde hier gelernt? Welchen Wert soll das Modell für den Input $17$ vorhersagen?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Beispiel3:\n",
+    "Ein Machine Learning Modell bekommt eine Liste von MP3 Dateien (zBsp eine Playlist auf Spotify) und soll die Lieder gruppieren. Das Modell bekommt keine anderen Infos und soll sich selber \"überlegen\", wie es am besten sortiert. Ein (für uns Menschen) vernünftiges Ergebnis wäre zum Beispiel eine Gruppierung nach Genre, Heavy Metal vs. Pop vs. Rap vs. Electronic zum Beispiel. Nun kann ein neues Item (ein neues Lied) auch in den Algorithmus gegeben werden und wir erhalten eine Gruppe für dieses Element. \n",
+    "\n",
+    "Was wurde hier ggf. gelernt? Was könnte noch gelernt worden sein? Handelt es sich hier um Supervised oder Unsupervised Learning?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Beispiel4:\n",
+    "Ein Machine Learning Modell bekommt eine Gallerie auf dem Smartphone voller Fotos. Es erstellt je nach abgebildeten Personen (hauptsächlich über das Gesicht) eigene Ordner welche nur Fotos von diesen Personen beinhalten.\n",
+    "\n",
+    "Was wurde hier gelernt? Ist es Supervised oder Unsupervised?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wir werden uns heuer noch mit folgenden **Supervised** Modellen befassen:\n",
+    "* **Regression und logistische Regression**\n",
+    "* **kNN (K-Nearest-Neighbor)**\n",
+    "* **SVM (Support Vector Machine)**\n",
+    "* **Decision Tree und Random Forests**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wir werden uns heuer noch mit folgenden **Unsupervised** Modellen befassen:\n",
+    "* **k-means und affinity propagation**\n",
+    "* **Downprojection**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wir werden uns jetzt am Anfang hauptsächlich mit **Supervised Machine Learning** Modellen beschäftigen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "___"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Supervised Machine Learning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Die wesentlichen Hauptkategorien im Bereich **Supervised Machine Learning** sind **Regression** und **Klassifikation**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![Classification vs. Regression](../resources/1_Classification_vs_Regression.jpg)\n",
+    "\n",
+    "(von https://www.simplilearn.com/regression-vs-classification-in-machine-learning-article)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Regression**:\n",
+    "* Für gegebene Features $X=(x_1, x_2, \\ldots, x_n)$ soll ein reeller Wert $y\\in\\mathbb{R}$ (=Label) vorhergesagt werden\n",
+    "* **Beispiel:** Aus Features Kilometerstand, Baujahr, Marke, Antriebsart, PS und Hubraum den Verkaufspreis eines Gebrauchtwagens vorhersagen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Classification**:\n",
+    "* Für gegebene Features $X=(x_1, x_2, \\ldots, x_n)$ soll eine Klasse (oft binär, zBsp Katze/Hund) $y\\in\\{0,1\\}$ (=Label) vorhergesagt werden\n",
+    "* **Beispiel:** Aus Features Blutdruck, Blutzucker, Rauchverhalten, BMI hervorsagen, ob eine Person Schlaganfall (Stroke) gefährdet ist"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Welche Art von Supervised Learning waren die beiden vorigen Beispiele?\n",
+    "\n",
+    "Müssen die Klassen immer $0,1$ sein bzw. für $n$ Klassen dann $0,1,\\ldots, n-1$?\n",
+    "\n",
+    "Inwiefern bringt uns hier ein **OrdinalEncoder** etwas? Was würde ein **OneHotEncoder** für einen Output liefern?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Bei jedem (Supervised) Modell gibt es immer 2 Phasen, von denen unterschieden werden muss:\n",
+    "* **Training** (Lernen)\n",
+    "* **Prediction** (Vorhersage), auch Inferenz genannt\n",
+    "\n",
+    "\n",
+    "Allgemein läuft der (ungefähre) Vorgang wie folgt ab:\n",
+    "* Auswahl einer Model-Klasse, abhängig von den gegebenen Daten bzw. des gewünschten Tasks\n",
+    "* Training (=Lernen) des Models mit den gegebenen Daten\n",
+    "* Testen, ob das gelernte Model \"gut\" ist\n",
+    "* Verwenden vom Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Lernen (Training) und Vorhersage (Prediction) von Modellen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Lernen (Training)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wir betrachten nun den Lernvorgang von einem Modell.\n",
+    "\n",
+    "**Wichtig:** Dieser Prozess ist, je nach verwendetem Modell Typ, sehr unterschiedlich. Je nach Typ wird beim Lernen versucht ein Fehler zu minimieren (Loss basiert) oder es nach anderen Kriterien optimiert zBsp.: Entropie bei Entscheidungsbäumen oder Decision Boundaries bei K-Nearest-Neighbor Modellen. \n",
+    "\n",
+    "Wir werden die verschiedenen Lernprozesse dann für die einzelnen Modelle genauer durchmachen.\n",
+    "\n",
+    "Als Beispiel betrachten wir jetzt das Lernen anhand von einem Regressionsmodell, welches versucht, eine Kurve (=Funktion, zBsp Polynom) in die gegebenen Daten (=Punkte) hinein zu legen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Man kann sich das Lernen in dem Fall von Regression auch iterativ vorstellen:\n",
+    "1. Punkte (Daten) sind gegeben.\n",
+    "1. Fixiere die Modell Klasse (Zum Beispiel Lineare Regression $y=kx+d$)\n",
+    "1. Wähle zufälliges $k,d$ und bewerte das Ergebnis\n",
+    "1. Ändere $k,d$, sodass Funktion besser in die Daten passt. Bewerte erneut, $\\ldots$ usw. bis Ergebnis zufriedenstellend.\n",
+    "\n",
+    "![Iterative Regression](../resources/1_Iterative_Regression.png)\n",
+    "\n",
+    "(von https://sandundayananda.medium.com/linear-regression-4c327a5d5ba7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nettes Tool zum Probieren: https://visualize-it.github.io/polynomial_regression/simulation.html\n",
+    "\n",
+    "Hier sieht man auch, wie sehr die Datenqualität eine Rolle spielt (betrachte sehr wenige Punkte, oder alle Punkte fast gleich)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prediction von Modellen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nachdem ein Modell fertig trainiert bzw. an den Daten angepasst wurde, kann es für die Prediction verwendet werden.\n",
+    "\n",
+    "Bei unserer linearen Regression würde das folgendes bedeuten:\n",
+    "* Wir fixieren nun $k$ und $d$ und ändern diese nicht mehr\n",
+    "* Der vorhergesagte Wert für einen neuen Datenpunkt $x_m\\in\\mathbb{R}$ wird dann berechnet, indem man einfach den Funktionswert für diesen Punkt berechnet\n",
+    "* $y_m = k \\cdot x_m + d$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Beurteilung des gelernten Models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sobald wir ein Modell fertig trainiert haben, ist es eine legitim zu Fragen **\"Wie gut das Modell nun eigentlich ist\"**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dieser Punkt wird **Modell Evaluierung** genannt. \n",
+    "\n",
+    "Welche Funktionen funktionieren [hier](https://visualize-it.github.io/polynomial_regression/simulation.html) gut und welche schlecht für verschiedene Datenpunkte? "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Obwohl das hier intuitiv recht gut funktioniert, kann man für größere Modelle nicht mehr rein intuitiv sagen, ob das Modell nun gut funktioniert, oder auch nicht.\n",
+    "\n",
+    "Dementsprechend gibt es eigene **Metriken**, welche trainierte Modelle evaluieren. Dies werden wir uns im nächsten Notebook ansehen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Aufgabe"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Überlege (oder verwende das Internet und recherchiere), welche Methode (Supervised/Unsupervised) die bekannten KI's im Alltag (Copilot, Bilderkennung, ChatGPT, Stable Diffusion, Self-Driving Cars,  etc.) verwenden\n",
+    "* Was sind die Daten? Was sind ggf. die Labels? Gibt es überhaupt Labels?\n",
+    "* Gibt es Tasks in deinem Alltag (oder zum Beispiel bei der Diplomarbeit), wo du glaubst, man könnte da vielleicht KI einsetzen? Gibt es dafür (labeled) Data?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dsai",
+   "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.9.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

05_ML/code/supervised_3_svm.ipynb

@@ -0,0 +1,690 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div style=\"\n",
+    "    border: 2px solid #4CAF50; \n",
+    "    padding: 15px; \n",
+    "    background-color: #f4f4f4; \n",
+    "    border-radius: 10px; \n",
+    "    align-items: center;\">\n",
+    "\n",
+    "<h1 style=\"margin: 0; color: #4CAF50;\">Supervised ML Modelle: Support-Vector-Machines</h1>\n",
+    "<h2 style=\"margin: 5px 0; color: #555;\">DSAI</h2>\n",
+    "<h3 style=\"margin: 5px 0; color: #555;\">Jakob Eggl</h3>\n",
+    "\n",
+    "<div style=\"flex-shrink: 0;\">\n",
+    "    <img src=\"https://www.htl-grieskirchen.at/wp/wp-content/uploads/2022/11/logo_bildschirm-1024x503.png\" alt=\"Logo\" style=\"width: 250px; height: auto;\"/>\n",
+    "</div>\n",
+    "<p1> © 2024/25 Jakob Eggl. Nutzung oder Verbreitung nur mit ausdrücklicher Genehmigung des Autors.</p1>\n",
+    "</div>\n",
+    "<div style=\"flex: 1;\">\n",
+    "</div>   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Teile (adaptiert) von *AI Inside Seminar KI Mag. Otto Reichel*!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Support Vector Machines (SVM's)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nun betrachten wir den Support Vector Machine (SVM) Klassifizierer. Es ist eine der am meisten theoretisch fundierten Machine Learning Modelle.\n",
+    "\n",
+    "Die SVM $\\ldots$\n",
+    "* $\\ldots$ wird bei uns verwendet zur Klassifizierung\n",
+    "* $\\ldots$ gibt es in 2 Varianten: **Linear SVM** und **Kernel SVM**\n",
+    "* $\\ldots$ hat wenige Hyperparameter ($C$ + Parameter für Kernel SVM)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Preview_3_Classes](../resources/SVM_Preview.jpg)\n",
+    "\n",
+    "(von https://spotintelligence.com/2024/05/06/support-vector-machines-svm/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Beschreibung des Algorithmus"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "SVM's sind Supervised Machine Learning Modelle, die versuchen, Muster in Daten zu erkennen, um die Daten zu klassifizieren. Ähnlich wie beim $k$-Nearest-Neighbour Klassifizierer, erhalten wir auch hier keine Wahrscheinlichkeiten zu bestimmten Klassenzugehörigkeiten, sondern nur die Vorhersage, ob ein bestimmter Datensatz zu einer Klasse gehört oder nicht.\n",
+    "\n",
+    "Dabei versuchen SVM's Trennlinien (im mehrdimensionalen Hyperebenen) zwischen den Bereichen so zu legen, dass der leere Bereich (=Streifen, genannt **Margin**) möglichst groß wird. Die folgende Abbildung zeigt dies für 2 klar getrennte Bereiche. In der Praxis ist die Ausgangslage meistens nicht so eindeutig, sprich hier ist es meistens *nicht* möglich, ohne Fehler eine Trennlinie/Hyperebene zu finden."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Margin_Visualization](../resources/SVM_Margin.png)\n",
+    "\n",
+    "(von https://www.iunera.com/kraken/fabric/support-vector-machines-svm/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Welche Hyperplane wäre hier die beste?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Multiple_Hyperplanes](../resources/SVM_Multiple_Hyperplanes.jpg)\n",
+    "\n",
+    "![SVM_Wrong_Hyperplanes](../resources/SVM_Wrong_Hyperplane.jpg)\n",
+    "\n",
+    "![SVM_Right_Hyperplanes](../resources/SVM_Right_Hyperplane.jpg)\n",
+    "\n",
+    "(von VL: Supervised Machine Learning JKU WS 2022)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Da der Trennbereich so groß wie möglich sein soll, ist klarerweise die letzte Hyperplane die beste."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training vs. Inferenz von SVM's"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wir wollen hier nochmal formal festhalten, wie eine Support Vector Machine an den Daten angepasst wird (Training) und wie sie dann verwendet wird.\n",
+    "\n",
+    "**Training:**\n",
+    "* Die optimale Hyperebene wird berechnet.\n",
+    "* Je nach Parameter $C$ werden mehr oder weniger Fehlklassifikationen erlaubt\n",
+    "\n",
+    "**Verwendung (=Inferenz):**\n",
+    "* Ein neuer Datenpunkt wird in den Raum gesetzt\n",
+    "* Je nachdem, auf welcher Seite der Punkt liegt, bekommt er das Label $1$ oder $0$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multiclass SVM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wie gehen wir vor, wenn wir mehrere Klassen haben?\n",
+    "\n",
+    "Hier gibt es *mehrere Möglichkeiten*.\n",
+    "\n",
+    "1. **One-vs-One (OvO)**\n",
+    "    * Für $N$ Klassen wird für jede mögliche Paarung von Klassen eine eigene SVM trainiert\n",
+    "    * Das bedeutet, es werden $N\\cdot (N-1)/2$​ Klassifikatoren trainiert\n",
+    "    * Vorhersage: Jeder Klassifikator gibt eine Stimme für eine der beiden Klassen ab, und die Klasse mit den meisten Stimmen gewinnt (Mehrheitsentscheidung)\n",
+    "    * Vorteil: Hohe Genauigkeit\n",
+    "    * Nachteil: Teuer (Rechenleistung) bei vielen Klassen\n",
+    "\n",
+    "2. **One-vs-All (OvA)**\n",
+    "    * Für $N$ Klassen werden $N$ SVMs trainiert\n",
+    "    * Jede SVM unterscheidet eine Klasse von allen anderen Klassen (z. B. \"Ist es Klasse A oder nicht?\")\n",
+    "    * Vorhersage: Die SVM mit der höchsten Entscheidungsfunktion bestimmt die Klasse\n",
+    "    * Vorteil: Weniger Modelle als *OvO*\n",
+    "    * Nachteil: Schlechtere Performance bei unausgeglichenen Daten"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die Support Vektoren"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nachdem dieses Machine Learning Modell *Support Vector Machine* heißt, ist diese Namensgebung zu hinterfragen sehr legitim. Der Name kommt von den sogenannten **Support Vektoren**.\n",
+    "\n",
+    "**Support Vektoren** (deutsch: Stützvektoren) sind die Datenpunkte, die am nächsten zur anderen Klasse sind. Diese werden verwendet, um die optimale Hyperebene zu finden. Die Berechnung der Hyperebene werden wir nicht händisch durchmachen, es kann bequem in Python gemacht werden. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Der Hyperparameter $C$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Wird **Regularisierungsparameter** genannt\n",
+    "* Kontrolliert den Trade-off zwischen **Maximierung der Margin** und **Minimierung von Fehlklassifikationen**\n",
+    "* Höheres $C$: Strengere Klassifikation, weniger Fehlklassifikationen erlaubt und somit kleinere Margin\n",
+    "* Niedrigeres $C$: Größere Margin, erlaubt mehr Fehlklassifikationen für bessere Generalisierung"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.datasets import make_classification\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "\n",
+    "# Dummy Dataset erstellen\n",
+    "X, y = make_classification(\n",
+    "    n_samples=200, \n",
+    "    n_features=2,    # Gesamtzahl der Features\n",
+    "    n_informative=2, \n",
+    "    n_redundant=0,   # Keine redundanten Features\n",
+    "    n_repeated=0,    # Keine wiederholten Features\n",
+    "    n_classes=2, \n",
+    "    n_clusters_per_class=1, \n",
+    "    random_state=42\n",
+    ")\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "scaler = StandardScaler()\n",
+    "X_train = scaler.fit_transform(X_train)\n",
+    "X_test = scaler.transform(X_test)\n",
+    "\n",
+    "# Verschiedene C-Werte testen\n",
+    "C_values = [0.01, 0.1, 1, 10, 100]\n",
+    "plt.figure(figsize=(15, 10))\n",
+    "\n",
+    "for i, C in enumerate(C_values, 1):\n",
+    "    model = SVC(C=C, kernel='linear')\n",
+    "    model.fit(X_train, y_train)\n",
+    "    \n",
+    "    # Plot der Entscheidungsgrenze\n",
+    "    plt.subplot(2, 3, i)\n",
+    "    plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='coolwarm', edgecolors='k')\n",
+    "    \n",
+    "    # Grenzen für die Darstellung\n",
+    "    ax = plt.gca()\n",
+    "    xlim = ax.get_xlim()\n",
+    "    ylim = ax.get_ylim()\n",
+    "    \n",
+    "    xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 100),\n",
+    "                         np.linspace(ylim[0], ylim[1], 100))\n",
+    "    Z = model.decision_function(np.c_[xx.ravel(), yy.ravel()])\n",
+    "    Z = Z.reshape(xx.shape)\n",
+    "    \n",
+    "    plt.contour(xx, yy, Z, levels=[-1, 0, 1], linestyles=['dashed', 'solid', 'dashed'], colors='black')\n",
+    "    plt.title(f'C = {C}')\n",
+    "    \n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Welche Werte von $C$ begünstigen *Overfitting* und welche *Underfitting*?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Kernel SVM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Als Motivation wird nun folgendes Szenario präsentiert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Annahme wir wollen folgende 2 Klassen mit Hilfe von einer Linie separieren."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Motivation_1d](../resources/Kernel_SVM_Motivation.jpg)\n",
+    "\n",
+    "(von https://medium.com/towards-data-science/svm-and-kernel-svm-fed02bef1200)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dies ist nicht möglich. Jedoch wäre es einfach, wenn wir auch nicht-lineare Separierungen zulassen würden. Dies ist equivalent zu folgendem."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Motivation_1d](../resources/Kernel_SVM_Motivation_Solution.jpg)\n",
+    "\n",
+    "(von https://medium.com/towards-data-science/svm-and-kernel-svm-fed02bef1200)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dies bringt uns zu den sogenannten **Kernel SVM's**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Da für komplizierte Datasets das finden einer *Ebene* nahezu unmöglich ist, gibt es eine Erweiterung zu den klassischen Support Vector Machines. Diese werden **kernel SVM's** genannt. Dabei werden die Datenpunkte mit Hilfe einer *kernel-Funktion* in einen höherdimensionalen Raum gebracht. Anschließend wird eine Hyperebene gesucht, welche die Daten separiert. Dieser Vorgang ist in den folgenden Bildern visualisiert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![Kernel_SVM_Preview](../resources/Kernel_SVM_Preview.jpg)\n",
+    "\n",
+    "![Kernel_SVM_Preview_2](../resources/Kernel_SVM_Preview2.jpg)\n",
+    "\n",
+    "(beide von https://medium.com/@abhishekjainindore24/svm-kernels-and-its-type-dfc3d5f2dcd8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Wichtig:** Mit *Kernel SVM* schaffen wir eine nichtlineare Separierung der Daten im ursprünglichen Raum. Der Umweg über einen höher-dimensionalen Raum, wo wir linear separieren können, beschreibt nur den Vorgang, der im Hintergrund passiert. Insgesamt sind wir trotzdem noch in eine (in diesem Fall *nichtlineare*) Separierung der Daten interessiert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Info:** Die Funktionsweise der *Kernel-SVM's* passiert mit dem sogenannten **Kernel-Trick**. Dieser erlaubt uns die effiziente Separierung auch in hohen Dimensionen am Computer. Dies wird hier nicht genauer erläutert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die verschiedenen Kernels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Linearer Kernel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "    \\phi(x,y)= x\\cdot y\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Linear_Kernel](../resources/SVM_linear_kernel.jpg)\n",
+    "\n",
+    "(von *Mathematical Pictures at a Data Science Exhibition*)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Polynomial Kernel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "\t\t\\phi(x, y) := \\left(x\\cdot y +\\beta\\right)^\\alpha,\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Polynomial_Kernel](../resources/SVM_Polynomial_Kernel3.png)\n",
+    "\n",
+    "(von *Mathematical Pictures at a Data Science Exhibition*)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### RBF Kernel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "    \\phi(x,y) = \\exp\\left(-\\frac{1}{2\\sigma^2}\\vert x-y\\vert^2\\right)\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_RBF_Kernel](../resources/SVM_Gaussian_Kernel.png)\n",
+    "\n",
+    "(von *Mathematical Pictures at a Data Science Exhibition*)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sigmoid Kernel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "    \\phi(x,y) = \\tanh(\\alpha (x\\cdot y) + \\beta)\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![SVM_Sigmoid_Kernel](../resources/SVM_sigmoid_kernel.jpg)\n",
+    "\n",
+    "(von [Link](https://www.linkedin.com/pulse/support-vector-machine-explained-theory-visualization-zixuan-zhang/))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vorteile und Nachteile von (Kernel) SVM's"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Vorteile:**\n",
+    "* Gute theoretische Fundierung (Eingeschränkte Optimierung)\n",
+    "* Schnelles Training und Testing\n",
+    "* Gute Performance bei hoher Anzahl an Features und nur begrenzter Anzahl an Datenpunkten\n",
+    "\n",
+    "**Nachteile:**\n",
+    "* Schlecht, wenn Daten mit viel Rauschen überlagert sind\n",
+    "* Wenig geeignet für große Datasets\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tipps und Tricks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Normalisierung (zBsp. $z$-score Normalisierung) der Daten auch hier erforderlich\n",
+    "* Wähle den richtigen Kernel!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (Kernel) SVM's in Python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn import datasets\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.metrics import accuracy_score, classification_report"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iris = datasets.load_iris()\n",
+    "X = iris.data[:, :2]  # Wir verwenden nur die ersten zwei Merkmale für bessere Visualisierung\n",
+    "y = iris.target\n",
+    "\n",
+    "# Aufteilen der Daten in Trainings- und Testset (80% Training, 20% Test)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SVM-Modell mit RBF-Kernel\n",
+    "svm_model = SVC(kernel='linear', gamma='scale', C=5.0)\n",
+    "svm_model = svm_model.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Vorhersagen auf dem Testset\n",
+    "y_pred = svm_model.predict(X_test)\n",
+    "\n",
+    "# Evaluierung der Genauigkeit\n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_decision_boundary(X, y, model):\n",
+    "    h = .02  # Schrittweite für das Meshgrid\n",
+    "    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
+    "    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
+    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
+    "\n",
+    "    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])\n",
+    "    Z = Z.reshape(xx.shape)\n",
+    "\n",
+    "    plt.contourf(xx, yy, Z, alpha=0.3)\n",
+    "    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', marker='o')\n",
+    "    plt.xlabel('Feature 1')\n",
+    "    plt.ylabel('Feature 2')\n",
+    "    plt.title('SVM Decision Boundary')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_decision_boundary(X_train, y_train, svm_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Was passiert bei einem linearen Kernel?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "svm_model = SVC(kernel='linear' C=1.0)\n",
+    "svm_model.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Vorhersagen auf dem Testset\n",
+    "y_pred = svm_model.predict(X_test)\n",
+    "\n",
+    "# Evaluierung der Genauigkeit\n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_decision_boundary(X_train, y_train, svm_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Aufgabe"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Verwende nun die folgenden Datasets und versuche die bestmögliche Performance zu erreichen.\n",
+    "* Lade dazu das Dataset mit den bekannten Methoden (Laden mit Hilfe von `pd.read_csv`)\n",
+    "* Überlege, wie du bei schlechter Performance diese verbessern kannst. Zum Beipsiel: Normalisieren, Ausreißer entfernen etc.\n",
+    "* Müssen wir ggf. Features entfernen?\n",
+    "* Gehören ggf. Features mit einem Ordinal-Encoder oder mit einem Onehot-Encoder encodiert?\n",
+    "* Verwende für jedes Dataset eigene Code-Zellen und dokumentiere für die verschiedenen Durchläufe die Ergebnisse (zBsp. Accuracy, Confusion Matrix oder den MSE)\n",
+    "\n",
+    "**Datasets:**\n",
+    "* Breast Cancer `breast_cancer.csv` (verwendet von https://archive.ics.uci.edu/dataset/17/breast+cancer+wisconsin+diagnostic)\n",
+    "* Diabetes `diabetes.csv` (verwendet von https://www.kaggle.com/uciml/pima-indians-diabetes-database)\n",
+    "* Stroke Prediction `stroke.csv` (verwendet von https://www.kaggle.com/datasets/fedesoriano/stroke-prediction-dataset)\n",
+    "\n",
+    "*Hinweis:* Überlege dir stets, welchen Problemtyp du verwendest und verwende dementsprechend das richtige Model! "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dsai",
+   "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.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}