691 lines
20 KiB
Plaintext
691 lines
20 KiB
Plaintext
{
|
||
"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": [
|
||
"\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": [
|
||
"\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": [
|
||
"\n",
|
||
"\n",
|
||
"\n",
|
||
"\n",
|
||
"\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": [
|
||
"\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": [
|
||
"\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": [
|
||
"\n",
|
||
"\n",
|
||
"\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": [
|
||
"\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": [
|
||
"\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": [
|
||
"\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": [
|
||
"\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
|
||
}
|