{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Klassifikation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wir nutzen ein Datenset, das handschriftliche Ziffern in Form von 8x8 Feldern mit Werten der Farbstärkte darstellt. Ein Beschreibung des Datensets gib es bei [scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits) und im \n", "[UC Irvine Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits).\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Wir importieren eine Funktion zu laden des Datensets und rufen dieses auf.\n", "from sklearn.datasets import load_digits\n", "digits = load_digits()" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sklearn.utils.Bunch" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Die Daten und Metadaten sind in einem sogenannten \"Bunch\"-Objekt organisiert\n", "type(digits)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['DESCR', 'data', 'images', 'target', 'target_names']" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Dieser Bunch hat folgende Attribute.\n", "dir(digits)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ".. _digits_dataset:\n", "\n", "Optical recognition of handwritten digits dataset\n", "--------------------------------------------------\n", "\n", "**Data Set Characteristics:**\n", "\n", " :Number of Instances: 5620\n", " :Number of Attributes: 64\n", " :Attribute Information: 8x8 image of integer pixels in the range 0..16.\n", " :Missing Attribute Values: None\n", " :Creator: E. Alpaydin (alpaydin '@' boun.edu.tr)\n", " :Date: July; 1998\n", "\n", "This is a copy of the test set of the UCI ML hand-written digits datasets\n", "https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits\n", "\n", "The data set contains images of hand-written digits: 10 classes where\n", "each class refers to a digit.\n", "\n", "Preprocessing programs made available by NIST were used to extract\n", "normalized bitmaps of handwritten digits from a preprinted form. From a\n", "total of 43 people, 30 contributed to the training set and different 13\n", "to the test set. 32x32 bitmaps are divided into nonoverlapping blocks of\n", "4x4 and the number of on pixels are counted in each block. This generates\n", "an input matrix of 8x8 where each element is an integer in the range\n", "0..16. This reduces dimensionality and gives invariance to small\n", "distortions.\n", "\n", "For info on NIST preprocessing routines, see M. D. Garris, J. L. Blue, G.\n", "T. Candela, D. L. Dimmick, J. Geist, P. J. Grother, S. A. Janet, and C.\n", "L. Wilson, NIST Form-Based Handprint Recognition System, NISTIR 5469,\n", "1994.\n", "\n", ".. topic:: References\n", "\n", " - C. Kaynak (1995) Methods of Combining Multiple Classifiers and Their\n", " Applications to Handwritten Digit Recognition, MSc Thesis, Institute of\n", " Graduate Studies in Science and Engineering, Bogazici University.\n", " - E. Alpaydin, C. Kaynak (1998) Cascading Classifiers, Kybernetika.\n", " - Ken Tang and Ponnuthurai N. Suganthan and Xi Yao and A. Kai Qin.\n", " Linear dimensionalityreduction using relevance weighted LDA. School of\n", " Electrical and Electronic Engineering Nanyang Technological University.\n", " 2005.\n", " - Claudio Gentile. A New Approximate Maximal Margin Classification\n", " Algorithm. NIPS. 2000.\n" ] } ], "source": [ "# Schauen wir uns mal die Beschreibung an\n", "print(digits.DESCR)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Die eigentlichen Daten sind in einem numpy-Array abgelegt.\n", "type(digits.data)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 5., ..., 0., 0., 0.],\n", " [ 0., 0., 0., ..., 10., 0., 0.],\n", " [ 0., 0., 0., ..., 16., 9., 0.],\n", " ...,\n", " [ 0., 0., 1., ..., 6., 0., 0.],\n", " [ 0., 0., 2., ..., 12., 0., 0.],\n", " [ 0., 0., 10., ..., 12., 1., 0.]])" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Schauen wir es uns mal an.\n", "digits.data" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1797, 64)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Schauen wir uns die Dimension der Matrix an - es handelt \n", "# sich um eine zweidimentionsale Matrix mit 1797 Zeilen und 64 Spalten.\n", "# Es sind 1797 Bilder und 64 (8x8 Felder) Features.\n", "digits.data.shape" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Das Target-Attribute ist ebenfalls ein numpy-array ...\n", "type(digits.target)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1797,)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ... allerding mit nur einer Dimension.\n", "digits.target.shape" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, ..., 8, 9, 8])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Jeder Wert entspricht der geschriebenen Nummer\n", "digits.target" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Das Bunch-Objekt hat noch das Attribute \"target_names\"\n", "# Normalerweise wird jeder Zahl in \"targent\" hier ein Name zugeordnen.\n", "# Da es sich aber tatsächlich um Ziffern von 0 - 9 handelt, ist das in diesem\n", "# nicht wirklich nötig.\n", "digits.target_names" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1797" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# In diesem Datenset gibt es zusätzlich noch ein Attribute \"images\".\n", "# Es enthält für jede geschriebene Ziffer die Farbwerte in ein 8x8 Matrix.\n", "len(digits.images)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 5., 13., 9., 1., 0., 0.],\n", " [ 0., 0., 13., 15., 10., 15., 5., 0.],\n", " [ 0., 3., 15., 2., 0., 11., 8., 0.],\n", " [ 0., 4., 12., 0., 0., 8., 8., 0.],\n", " [ 0., 5., 8., 0., 0., 9., 8., 0.],\n", " [ 0., 4., 11., 0., 1., 12., 7., 0.],\n", " [ 0., 2., 14., 5., 10., 12., 0., 0.],\n", " [ 0., 0., 6., 13., 10., 0., 0., 0.]])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Schauen wir uns zum Beispiel das erst Bild an ...\n", "digits.images[0]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 11., 12., 0., 0., 0., 0.],\n", " [ 0., 2., 16., 16., 16., 13., 0., 0.],\n", " [ 0., 3., 16., 12., 10., 14., 0., 0.],\n", " [ 0., 1., 16., 1., 12., 15., 0., 0.],\n", " [ 0., 0., 13., 16., 9., 15., 2., 0.],\n", " [ 0., 0., 0., 3., 0., 9., 11., 0.],\n", " [ 0., 0., 0., 0., 9., 15., 4., 0.],\n", " [ 0., 0., 9., 12., 13., 3., 0., 0.]])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ... oder das zehnte Bild\n", "digits.images[9]" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Wir können die in dieser Form gespeicherten Farbintensitäten\n", "# auch mit matplotlib anzeigen lassen. Hier zum Beispiel für die\n", "# ersten 30 Bilder (wenn man mehr haben möchte muss man in subplot\n", "# mehr als 3 Zeilen angeben.)\n", "import matplotlib.pyplot as plt\n", "fig, axes = plt.subplots(3, 10, figsize=(10, 5))\n", "for ax, img in zip(axes.ravel(), digits.images):\n", " ax.imshow(img, cmap=plt.cm.gray_r)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# Um einen Klassifikator für ein Klassifikation zu trainieren\n", "# und dann später seine Güte zu bewerten, wird das Datenset \n", "# (genauer gesagt die Attribute \"data\" und \"target\") in\n", "# ein Trainingsset (75%) und Testset (25%) aufgeteilt. Die Konvention\n", "# ist hier eine großes X für den Variablen der Datenmatrix und ein kleines y\n", "# für den Target-Vektor zu nutzen.\n", "\n", "# Anmerkung - bei einigen der folgenden Schritte wird \n", "# von bestimmten zufälligen Zuständen ausgegagen. Um diese\n", "# fest zu setzen und somit die Analyse reproduzierbar zu machen\n", "# kann man den Parameter random_state nutzen und mit einer Zahl\n", "# versehen.\n", "\n", "from sklearn.model_selection import train_test_split\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " digits['data'], digits['target'], random_state=1)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1347, 64)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Die Maße der zweidimensionalen Trainigs-Daten-Matrix\n", "X_train.shape" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(450, 64)" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Die Maße der zweidimensionalen Test-Daten-Matrix\n", "X_test.shape" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1347,)" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Die Länge des Trainingsvektor entspricht der Anzahl an \n", "# Zeilen der Trianingsmatrix.\n", "y_train.shape" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(450,)" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Die Länge des Testsvektors entspricht der Anzahl an \n", "# Zeilen der Testsmatrix.\n", "y_test.shape" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Wir werden zuerst mit einem k-Nearest-Neighbor-Klassifizierer Arbeiten\n", "# und laden dazu die Klasse ...\n", "from sklearn.neighbors import KNeighborsClassifier" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# ... und erzeugen ein Objekt davon. Hierbei können wird die Anzahl an \n", "# zu betrachteten Nachbarn angeben:\n", "knn_clf = KNeighborsClassifier(n_neighbors=1)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n", " metric_params=None, n_jobs=None, n_neighbors=1, p=2,\n", " weights='uniform')" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Jetzt trainieren wir den Klassifikator mit den Trainingsdaten.\n", "# Dafür wird in scikit-learn unabhängig von Klassifikator die\n", "# Methode \"fit\" genutzt.\n", "knn_clf.fit(X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 5, 0, 7, 1, 0, 6, 1, 5, 4, 9, 2, 7, 8, 4, 6, 9, 3, 7, 4, 7, 1,\n", " 8, 6, 0, 9, 6, 1, 3, 7, 5, 9, 8, 3, 2, 8, 8, 1, 1, 0, 7, 9, 0, 0,\n", " 8, 7, 2, 7, 4, 3, 4, 3, 4, 0, 4, 7, 0, 5, 5, 5, 2, 1, 7, 0, 5, 1,\n", " 8, 3, 3, 4, 0, 3, 7, 4, 3, 4, 2, 9, 7, 3, 2, 5, 3, 4, 1, 5, 5, 2,\n", " 9, 2, 2, 2, 2, 7, 0, 8, 1, 7, 4, 2, 3, 8, 2, 3, 3, 0, 2, 9, 3, 2,\n", " 3, 2, 8, 1, 1, 9, 1, 2, 0, 4, 8, 5, 4, 4, 7, 6, 7, 6, 6, 1, 7, 5,\n", " 6, 3, 8, 3, 7, 1, 8, 5, 3, 4, 7, 8, 5, 0, 6, 0, 6, 3, 7, 6, 5, 6,\n", " 2, 2, 2, 3, 0, 7, 6, 5, 6, 4, 1, 0, 6, 0, 6, 4, 0, 9, 3, 8, 1, 2,\n", " 3, 1, 9, 0, 7, 6, 2, 9, 3, 5, 3, 4, 6, 3, 3, 7, 4, 9, 2, 7, 6, 1,\n", " 6, 8, 4, 0, 3, 1, 0, 9, 9, 9, 0, 1, 8, 6, 8, 0, 9, 5, 9, 8, 2, 3,\n", " 5, 3, 0, 8, 7, 4, 0, 3, 3, 3, 6, 3, 3, 2, 9, 1, 6, 9, 0, 4, 2, 2,\n", " 7, 9, 1, 6, 7, 6, 3, 9, 1, 9, 3, 4, 0, 6, 4, 8, 5, 3, 6, 3, 1, 4,\n", " 0, 4, 4, 8, 7, 9, 1, 5, 2, 7, 0, 9, 0, 4, 4, 0, 1, 0, 6, 4, 2, 8,\n", " 5, 0, 2, 6, 0, 1, 8, 2, 0, 9, 5, 6, 7, 0, 5, 0, 9, 1, 4, 7, 1, 7,\n", " 0, 6, 6, 8, 0, 2, 2, 6, 9, 9, 7, 5, 1, 7, 6, 4, 6, 1, 9, 4, 7, 1,\n", " 3, 7, 8, 1, 6, 9, 8, 3, 2, 4, 8, 7, 5, 5, 6, 9, 9, 8, 5, 0, 0, 4,\n", " 9, 3, 0, 4, 9, 4, 2, 5, 4, 9, 6, 4, 2, 6, 0, 0, 5, 6, 7, 1, 9, 2,\n", " 5, 1, 5, 9, 8, 7, 7, 0, 6, 9, 3, 1, 9, 3, 9, 8, 7, 0, 2, 3, 9, 9,\n", " 2, 8, 1, 9, 3, 3, 0, 0, 7, 3, 8, 7, 9, 9, 7, 1, 0, 4, 5, 4, 1, 7,\n", " 3, 6, 5, 4, 9, 0, 5, 9, 1, 4, 5, 0, 4, 3, 4, 2, 3, 9, 0, 8, 7, 8,\n", " 6, 9, 4, 5, 7, 8, 3, 7, 8, 3])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Herzlichen Glückwunsch - wir haben unser aller erstes \n", "# Klassifikator-Modell gebaut und trainiert. \n", "# Jetzt kann mit diesem neue Daten (also Vektoren der Länger 64, die\n", "# die 8x8 Bilder darstellen) klassifizieren - in diesem\n", "# Fall also Vorauszusagen, welche Ziffer dargestellt wurde.\n", "#\n", "# Wir haben unsere Testdaten noch verfügbar und können die Methode \"predict\"\n", "# des trainierten Klassifiers nutzen und erhalten die Voraussagen.\n", "knn_clf.predict(X_test)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9888888888888889" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Da wir für das Testset aber auch wissen welche Ziffern tatsächlich \n", "# herauskommen sollte, können wir die Methode \"score\" des Klassifiers \n", "# nutzen. Diese führt die Voraussage durch und vergleicht sie mit den \n", "# tatsächlichen Target-Werten. Am Ende bekommen wir einen Wert zwischen \n", "# 0 (schlecht) und 1 (gut).\n", "knn_clf.score(X_test, y_test)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9911111111111112" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Jetzt führen wir die das gleich Verfahren (Erstellen, Traininen und Testen)\n", "# dieses Classifiers mit 3 Nachbarn als Parameter durch.\n", "knn_clf_3 = KNeighborsClassifier(n_neighbors=3)\n", "knn_clf_3.fit(X_train, y_train)\n", "knn_clf_3.score(X_test, y_test)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "# Das schöne an scikit-learn ist, dass alle Klassifikatoren \n", "# die gleichen Methoden besitzten. Sprich anderen Klassifikatoren\n", "# nutzen auch fit, predict und score.\n", "#\n", "# Machen wir eine Klassifikation mit einem Random-Forest-Klassifikator:\n", "from sklearn.ensemble import RandomForestClassifier\n", "random_forest_cfl = RandomForestClassifier(random_state=1)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n", " criterion='gini', max_depth=None, max_features='auto',\n", " max_leaf_nodes=None, max_samples=None,\n", " min_impurity_decrease=0.0, min_impurity_split=None,\n", " min_samples_leaf=1, min_samples_split=2,\n", " min_weight_fraction_leaf=0.0, n_estimators=100,\n", " n_jobs=None, oob_score=False, random_state=1, verbose=0,\n", " warm_start=False)" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "random_forest_cfl.fit(X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.98" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "random_forest_cfl.score(X_test, y_test)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "# Das gleiche machen wir nur für eine Klassifikation mit einem \n", "# künstlichen, neuralen Netz (Multi-Layer-Perceptron). Standardmäßig \n", "# hat das Netz ein eine Hidden-Layer mit 100 Nodes.\n", "from sklearn.neural_network import MLPClassifier" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,\n", " beta_2=0.999, early_stopping=False, epsilon=1e-08,\n", " hidden_layer_sizes=(100,), learning_rate='constant',\n", " learning_rate_init=0.001, max_fun=15000, max_iter=200,\n", " momentum=0.9, n_iter_no_change=10, nesterovs_momentum=True,\n", " power_t=0.5, random_state=1, shuffle=True, solver='adam',\n", " tol=0.0001, validation_fraction=0.1, verbose=False,\n", " warm_start=False)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mlpc = MLPClassifier(random_state=1)\n", "mlpc.fit(X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9755555555555555" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mlpc.score(X_test, y_test)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9844444444444445" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Wir können die Anzahl an Hidden-Layer und Anzahl an Nodes in diesen\n", "# als Parameter setzen (hier 3 Schichten mit mit 200, 100 und 20 Nodes).\n", "# Man kann das ganze kondenensiert schreiben, indem man die\n", "# Methodenaufrufe direkt verknüpft.\n", "MLPClassifier(random_state=1, hidden_layer_sizes=(200, 100, 20)).fit(\n", " X_train, y_train).score(X_test, y_test)" ] } ], "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.6" } }, "nbformat": 4, "nbformat_minor": 2 }