{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Maschinelles Lernen (ML), Praktikum 2\n", "Dieser Kurs vermittelt den Umgang mit den Pythonbibliotheken `matplotlib`, `NumPy`, `Pandas` und `Scikit-Learn`. Dabei werden Sie anhand eines Beispielprojekts vom Anfang bis zum Ende geführt. Im Rahmen dieser Übung werden Sie die folgenden Schritte durchlaufen: \n", "- Einführung in Numpy, Pandas und Matplotlib\n", "- Daten auswerten und visualisieren, um Erkenntnisse zu gewinnen\n", "- Vorbereitung der Daten\n", "- Modell Auswahl und Training \n", "- Präsentieren Sie Ihre Lösung\n", "\n", "In dieser Übung experimentieren Sie mit realen Datensätzen. Hierfür stehen einige frei verfügbare Datensätze aus unterschiedlichen Fachgebieten zur Verfügung: \n", "- [UC Irvine Machine Learning Repository](http://archive.ics.uci.edu/ml/)\n", "- [Kaggle](https://www.kaggle.com/datasets)\n", "- [Amazon AWS](http://aws.amazon.com/fr/datasets/)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Einführung in Numpy, Matplotlib und Pandas\n", "\n", "Numpy ist eine Python-Bibliothek, die für numerische Berechnungen verwendet wird. Numpy stellt hauptsächlich ein mehrdimensionales Array-Objekt zusammen mit effizient implementierten Funktionen zur Verfügung. Um Numpy zu nutzen müssen wir es zunächst importieren. Üblicherweise bindet man es unter dem Namen `np` ein." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Praktische mathematische Funktionen:\n", "\n", "| Operator | Beschreibung |\n", "|--------------|----------------------------------------------------------|\n", "| ``np.linalg.inv`` | Inverse der Matrix |\n", "| ``np.linalg.eig`` | Eigenwerte der Matrix |\n", "| ``np.matmul`` | Matrix-Multiplikation |\n", "| ``np.zeros`` | Matrix mit Nullen erstellen (`.ones` für Einsen) |\n", "| ``np.arange`` | Start, Stopp und Schrittweite |\n", "| ``np.identity`` | Create an identity matrix |\n", "| ``np.vstack`` | Vertically stack 2 arrays |\n", "\n", "\n", "\n", "Hilfreiche Funktionen für die Fehlersuche:\n", "\n", "| Operator | Beschreibung |\n", "|--------------------------------|--------------------------------------------------|\n", "| ``array.shape`` | Form des Numpy-Arrays abfragen |\n", "| ``array.dtype`` | Datentyp des Arrays prüfen |\n", "| ``type(stuff)`` | Typ einer Variablen abfragen |\n", "| ``print(f\"Data type of integer is {name}\")`` | Einfacher Weg eine Nachricht zu erzeugen |\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Allgemeine Numpy Verwendung\n", "Initialisierung mit Listen:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "array_1d = np.array([1, 2, 3, 4])\n", "print(array_1d.shape)\n", "array_1by4 = np.array([[1, 2, 3, 4]])\n", "print(array_1by4.shape)\n", "\n", "large_array = np.array([i for i in range(400)])\n", "print(large_array.shape)\n", "\n", "large_array = large_array.reshape((20, 20))\n", "print(large_array.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Listen mit verschiedenen Typen. Numpy verwendet einen Autocasts, der dem Array `from_list_2d` automatisch eine höherere Präzision zuweist." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from_list = np.array([1, 2, 3])\n", "from_list_2d = np.array([[1, 2, 3.0], [4, 5, 6]])\n", "from_list_bad_type = np.array([1, 2, 3, \"a\"])\n", "\n", "print(f'Data type of integer is {from_list.dtype}')\n", "print(f'Data type of float is {from_list_2d.dtype}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy unterstützt viele Arten von algebraischen Operationen auf einem ganzen Array" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "array_1d + 5\n", "array_1d * 5\n", "np.sqrt(array_1d)\n", "np.power(array_1d, 2)\n", "np.exp(array_1d)\n", "np.log(array_1d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Punktprodukt und Matrix-Multiplikation\n", "Einige Möglichkeiten das Punktprodukt zu schreiben" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "array_1d @ array_1d\n", "array_1d.dot(array_1d)\n", "np.dot(array_1d, array_1d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Matrix-Multiplikation" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "weight_matrix = np.array([1, 2, 3, 4]).reshape(2, 2)\n", "sample = np.array([[50, 60]]).T\n", "np.matmul(weight_matrix, sample)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2D Matrix-Multiplikation" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mat1 = np.array([[1, 2], [3, 4]])\n", "mat2 = np.array([[5, 6], [7, 8]])\n", "np.matmul(mat1, mat2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Elementweise Multiplikation" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = np.array([i for i in range(10)]).reshape(2, 5)\n", "a * a\n", "np.multiply(a, a)\n", "np.multiply(a, 10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting\n", "Matplotlib kann zum Erstellen von Plots und Diagrammen verwendet werden. Üblicherweise bindet man es unter dem Namen `plt` ein. Die Bibliothek wird wie folgt verwendet:\n", "1. Aufruf einer Plotting-Funktion mit einigen Daten mit `.plot()`.\n", "2. Funktionen aufrufen, um die Eigenschaften des Plots einzustellen (z.B. Beschriftungen und Farben).\n", "3. Den Plot sichtbar machen mit `.show()`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Import\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "# Create data\n", "t = np.arange(0.0, 2.0, 0.01)\n", "s = 1 + np.sin(2 * np.pi * t)\n", "\n", "# Plotting\n", "fig, ax = plt.subplots()\n", "ax.plot(t, s)\n", "ax.set(xlabel = \"time (s)\", ylabel = \"voltage (mV)\", title = \"About as simple as it gets, folks\")\n", "ax.grid()\n", "fig.savefig(\"test.png\") # Saves the current plot into a .png file located in the same folder\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot mit gestrichelten Linien und einer Legende" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "x = np.linspace(0, 10, 500)\n", "y = np.sin(x)\n", "\n", "fig, ax = plt.subplots()\n", "\n", "line1, = ax.plot(x, y, label = \"Using set_dashes()\")\n", "# 2pt line, 2pt break, 10pt line, 2pt break\n", "line1.set_dashes([2, 2, 10, 2])\n", "\n", "line2, = ax.plot(x, y - 0.2, dashes=[6, 2], label = \"Using the dashes parameter\")\n", "\n", "ax.legend()\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pandas \n", "Pandas bietet Datenstrukturen und Funktionen zur schnellen Manipulation und Analyse von Daten. Es setzt dabei auf die effizienten Datenmodelle von Numpy auf und analysiert Tabellen in verschiedenen Größen in Sekundenbruchteilen. Für das Maschinelle Lernen ist Pandes eine hilfreiche Bibliothek, da die Pandas-Dataframes und die Tabellenobjekte\n", "des Frameworks grafisch als Tabellen aufbereitet werden. Üblicherweise bindet man Pandas unter dem Namen `pd` ein." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pandas as pd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nun laden wir die Daten mit Pandas. Ums Einlesen kümmert sich ``pd.read_csv()``. Die Spaltennamen können mit einer Liste ``names`` per Hand festgelegt werden, falls die Datei keine zufriedenstellenden Spaltennamen liefert. Pandas bestimmt die Datentypen der Spalten automatisch, arbeitet aber schneller, wenn man die Typen als Dictionary im Parameter ``dtype`` definiert." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "names = [\"sepal-length\", \"sepal-width\", \"petal-length\", \"petal-width\", \"class\"]\n", "\n", "# Optional\n", "# dtype={\"sepal-length\": float,\n", "# \"sepal-width\": float,\n", "# \"petal-length\": float,\n", "# \"petal-width\": float, \n", "# \"class\": str})\n", "\n", "iris_data = pd.read_csv(\"iris.csv\", names = names)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ein Blick auf den Datensatz\n", "Wir verwenden den Iris-Datensatz, um die Klassifikation zu veranschaulichen. Es handelt sich hierbei um einen Datensatz, der die Länge und Breite der Kelchblätter (engl. sepal) und Kronblätter (engl. petal) von 150 Iris-Blüten aus drei Unterarten unterscheidet: *Iris-Setosa*, *Iris-Virginica* und *Iris-Versicolor*. \n", "\n", "
\n", "\"iris\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ein Blick auf die Daten\n", "Schauen wir uns die ersten fünf Zeilen des DataFrames mit der Methode `.head()` an. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iris_data.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jede Zeile steht für eine Messung. Es gibt vier Merkmale: *sepal-length*, *sepal-width*, *petal-length* und *petal-width*. Sie Spalte *class* gibt das dazugehörige Label an. Die Methode `.info()` hilft, schnell eine Beschreibung der Daten zu erhalten. Die Funktion gibt eine Übersicht der Zeilenanzahl, den Typ jedes Attributs und die Anzahl der Werte, die ungleich null sind an. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iris_data.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Methode `.describe()` fasst die numerischen Merkmale zusammen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iris_data.describe()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Eine Möglichket, nach nach sinnvollen Merkmalskombinationen zu suchen, ist die in Pandas eingebaute Funktion ``scatter_matrix``, die jedes numerische Merkmal gegen jedes andere aufträgt." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Scatter plot matrix\n", "from pandas.plotting import scatter_matrix\n", "from matplotlib import pyplot\n", "\n", "scatter_matrix(iris_data)\n", "pyplot.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Seaborn](https://seaborn.pydata.org/index.html) ist eine Python-Datenvisualisierungsbibliothek, die auf der Matplotlib basiert. Sie bietet eine High-Level-Schnittstelle zum Zeichnen attraktiver und informativer statistischer Grafiken." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import seaborn as sns\n", "\n", "df = iris_data\n", "sns.pairplot(df, hue=\"class\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Umgang mit Text und kategorischen Einträgen\n", "Bisher haben wir uns nur mit numerischen Spalten befasst, aber jetzt wollen wir uns die Textspalten ansehen. In diesem Datensatz ist das die Spalte *class*." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iris_categories = iris_data['class']\n", "iris_categories.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Es ist kein willkürlicher Text. Es gibt eine begrenzte Anzahl von möglichen Werten, von denen jeder eine Kategorie bzw. Klasse repräsentiert. Die meisten Algorithmen arbeiten lieber mit Zahlen, also transformieren wir diese Kategorie in Zahlen um. Hierfür können wir die Klasse `LabelEncoder` von Scikit-Learn verwenden.\n", "\n", "**Notiz.** [*Scikit-Learn*](http://scikit-learn.org/) enthält effiziente Implementierungen vieler Machine-Learning-Algorithmen. Es bietet einen guten Ausgangspunkt verschiedene Algorithmen auszutesten, ohne jeden einzelnen zu entwickeln. Einen Kurzüberblick über Scikit-Learn finden Sie in dem Ilias Ordner." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.preprocessing import LabelEncoder\n", "lb_make = LabelEncoder()\n", "iris_data[\"class_code\"] = lb_make.fit_transform(iris_data[\"class\"])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iris_categories = iris_data[\"class_code\"]\n", "iris_data.describe()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Klassifikation\n", "Für den Anfang werden wir die Klassifizierung vereinfachen und lediglich versuchen, zwei Unterarten der Iris-Blüte zu erkennen. Dieser Ansatz ist ein Beispiel für einen *binären Klassifikator*, mit dem sich genau zwei Kategorien unterscheiden lassen (z.B. *Iris-versicolor* und *Iris-virginica*). Erstellen wir also zunächst einen Datensatz mit den beiden Klassen *Iris-versicolor* und *Iris-virginica*." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "iris_data = " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In einem weiteren Schritt erstellen wir den Zielvektor $y$ für diese Klassifikationsaufgabe. Bei einer überwachten Lernaufgabe sind das die Labels in dem Datensatz." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Sie können eine Variable mit Punkt-Notation extrahieren\n", "y = " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Auswahl von Merkmale (engl. Features)\n", "Die Spalten, die dem Modell als Input dienen (und später zur Erstellung von Vorhersagen verwendet werden), werden als Merkmale (engl. Features) bezeichnet. Vorerst werden wir ein Modell mit nur zwei Merkmalen erstellen. Die Auswahl mehrerer Merkmale erfolgt durch eine Liste der Spaltennamen. Jedes Element in dieser Liste sollte eine Zeichenfolge sein (String). \n", "\n", "**Aufgabe 2.1:** Wählen Sie zwei geeignete Merkmale. Verwenden Sie dafür die oben beschriebene Scatter-Matrix. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Merkmale auswählen und berechnen\n", "''' Hilfe\n", "Plotten Sie die Merkmale in einem zweidimensionalem Scatterplot. Unterscheiden Sie dabei „gute“ \n", "und „schlechte“ Merkmale voneinander. Eignen sich die gewählten Merkmale für eine Klassifikation oder eher nicht?\n", "'''\n", "iris_features = \n", "X = iris_data[iris_features]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bevor wir nun einen Klassifikator auswählen und trainieren, sollten Sie einen Testdatensatz erstellen, beiseitelegen und nicht mehr hineinschauen.\n", "\n", "#### Testdatensatz erstellen\n", "Bis jetzt haben wir kurzen Blick auf die Daten geworfen und sicherlich sollten Sie noch eine ganze Menge mehr darüber lernen, bevor Sie entscheiden, welche Algorithmen Sie verwenden. Das kann aber dazu führen, dass Ihr Gehirn (ein erstaunliches Mustererkennungssystem) anfällig für eine Überanpassung des Problems wird (engl. Overfitting). Sie auf ein scheinbar interessantes Muster stoßen, welches eine bestimmte Art von Modell bevorzugt. Dieses Problem wird auch als *Data Snooping-Bias* bezeichnet. \n", "\n", "
\n", "\"train-test\"\n", "
\n", "\n", "Einen Testdatensatz zu erstellen, ist sehr einfach. Wählen Sie zufällig einige Datenpunkte aus (meist 20% des Datensatzes) und legen Sie diese beiseite. `train_test_split(...)` ist eine Funktion in Sklearn zur Aufteilung des Datensatzes in Trainingsdaten und in Testdaten. Die Funktion hat mehrere Parameter. Ein einfaches Beispiel für die Syntax würde wie folgt aussehen: \n", "\n", "`train_test_split(X, y, train_size=0.*, test_size=0.*, random_state=*)`\n", "- `X, y` Als erster Parameter wird der Datensatz angegeben, den Sie verwenden möchten.\n", "- `train_size` Dieser Parameter legt die Größe des Trainingsdatensatzes fest, die zwischen 0,1 und 1,0 liegt.\n", "- `test_size` Dieser Parameter gibt die Größe des Testdatensatzes.\n", "- `random_state` Der Standardmodus führt eine zufällige Aufteilung unter Verwendung von `np.random.seed(any_number)`.\n", "\n", "\n", "**Aufgabe 2.2:** Teilen Sie den Datensatz in einen Trainings- und einen Testdatensatz auf. Verwenden Sie dabei einen 80/20 split." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "X_train, X_test, y_train, y_test = " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Trainieren und Auswerten\n", "Wir wissen nicht, welche Algorithmen für dieses Problem gut geeignet wären oder welche Konfigurationen verwendet werden sollten. Aus den Darstellungen haben wir die Idee gewonnen, dass einige der Klassen teilweise linear trennbar sind, so dass insgesamt gute Ergebnisse zu erwarten sind. Lassen Sie uns drei verschiedene Algorithmen untersuchen:\n", "- Logistic Regression (LR),\n", "- k-Nearest Neighbors (KNN) und eine\n", "- Support Vector Machines (SVM).\n", "\n", "Dies ist eine gute Mischung aus einfachen linearen (LR) und nicht-linearen (KNN, SVM) algorithmen. [*Scikit-Learn*](http://scikit-learn.org/) enthält bereits effiziente Implementierungen der drei Machine-Learning-Algorithmen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import accuracy_score\n", "\n", "model_lr = LogisticRegression(solver='liblinear', multi_class='ovr')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Um das Training zu starten, reicht ein Aufruf von `.fit(..)`. Die Funktion nimmt als Parameter den zuvor erstelten Trainingsdatensatz entgegen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model_lr.fit(X_train, y_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nach dem Training könnten Sie das Model evaluieren. Übergeben Sie hierfür der Funktion `.predict(...)` mit Daten. Als Qualitätsmaß verwenden wir die Genauigkeit (engl. Accuracy), die den Prozentwert der korrekt klassifizierten Prädiktionen angibt:\n", "$$ \\mathrm{Accuracy} = \\frac{\\mathrm{TP} + \\mathrm{TN}}{\\mathrm{TP} + \\mathrm{TN} + \\mathrm{FP} + \\mathrm{FN}} $$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \"conf-matrix\"\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model_lr_predictions = model_lr.predict(X_train)\n", "print(accuracy_score(y_train, model_lr_predictions))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 2.3:** Vervollständigen Sie die Code-Zellen für die beiden anderen Klassifikatoren und geben Sie jeweils die Accuracy für den Trainings- und Testdatensatz aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.neighbors import KNeighborsClassifier\n", "\n", "model_knn = KNeighborsClassifier()\n", "\n", "# ..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.svm import SVC\n", "model_svc = SVC(gamma='auto')\n", "\n", "# ..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 2.5:** Entwerfen Sie einen einfachen binären Klassifikator, der nur eine Zahl in einem Datensatz erkennt. Verwenden Sie hierfür den MNIST-Datensatz. Dieser beinhaltet eine Sammlung von 70000 Bildern handschriftlicher Ziffern, die von Oberschülern und Mitarbeitern des US Census Bureaus aufgeschrieben wurden. Jedes Bild ist mit der dargestellten Ziffer gelabelt." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Vorbereitungen\n", "In dem Datensatz gibt es 70000 Bilder, jedes davon hat 768 Merkmale. Das liegt daran, das jedes Bild aus 28 x 28 Pixeln besteht und jedes Merkmal die Intensität eines Pixels von\n", "0 (weiß) bis 255 (schwarz) enthält. Betrachten wir eine Ziffer aus dem Datensatz. Dazu muss der Merkmalsvektor eines Datenpunkts herausgreifen werden, zu einem Array mit den Abmessungen 28 x 28 umformatieren und mit der Funktion imshow() aus Matplotlib dargestellt werden:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mnist = pd.read_csv(\"mnist_train.csv\")\n", "mnist.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mnist.head()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "X_train, y_train = mnist.drop(['label'],axis=1).values, mnist[\"label\"]\n", "X_train.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "y_train.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "some_digit = X_train[22000]\n", "some_digit_image = some_digit.reshape(28, 28)\n", "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary,\n", "interpolation=\"nearest\")\n", "plt.axis(\"off\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Entwickeln Sie einen binären Klassifikator:\n", "- Erstellen Sie den Zielvektor. Verden Sie hierfür den Befehl `y_train_my_number = (y == my_number)`. Die Aussage ist True bei allen \"my_number\" und False bei allen anderen Ziffern. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code ...\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Wählen Sie einen Klassifikator aus, trainieren diesen und geben Sie die Accuracy an. In diesem Fall ist es ratsam das *stochastische Gradientenverfahren* (SGD) als Klassifikator zu verwenden. Er ist in der Klasse SGDClassifier in Scikit-Learn enthalten. Dieser Klassifikator hat den Vorteil, sehr große Datensätze effizient zu bearbeiten." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.linear_model import SGDClassifier\n", "sgd_clf = " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Vergleich Sie Ihr Ergebnis mit einen sehr primitiven Klassifikator, der einfach jedes Bild der Kategorie ``never_my_number`` zuordnet:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sklearn.base import BaseEstimator\n", "class NeverMyNumberClassifier(BaseEstimator):\n", " def fit(self, X, y=None):\n", " pass\n", " def predict(self, X):\n", " return np.zeros((len(X), 1), dtype=bool)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "never_my_number_clf = NeverMyNumberClassifier()\n", "never_my_number_clf.fit(X, y_train_my_number)\n", "never_my_number_clf_predictions = never_my_number_clf.predict(X)\n", "print(accuracy_score(y_train_my_number, never_my_number_clf_predictions))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Versuchen Sie mit eigenen Worten zu erklären, warum diese Genauigkeit mit einem solchen primitiven Klassifikator erreicht wird. \n", "\n", "- Zur Bewertung der Güte eines Klassifikator existieren noch andere Metriken, die ihre eigenen Vor- und Nachteile haben. Welches sind die bekanntesten Metriken und warum könnte es wichtig sein, die richtige Metrik für die richtige Situation zu wählen? " ] }, { "cell_type": "markdown", "metadata": {}, "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.7" } }, "nbformat": 4, "nbformat_minor": 4 }