PVA8.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.models import Sequential\n",
    "from keras.layers.core import Dense\n",
    "from keras.utils import np_utils\n",
    "from keras.datasets import mnist\n",
    "\n",
    "(XTrain, yTrain), (XTest, yTest) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Umwalndlung in Vektoren\n",
    "XTrain = XTrain.reshape(60000, 784)\n",
    "XTest = XTest.reshape(10000, 784)\n",
    "# Skalierung durch Dision durch 255\n",
    "XTrain = XTrain/255\n",
    "XTest = XTest/255\n",
    "\n",
    "# Klassenvektoren in binäre Klassenmatrizen\n",
    "YTrain = np_utils.to_categorical(yTrain, 10)\n",
    "YTest = np_utils.to_categorical(yTest, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "2500/2500 [==============================] - 2s 704us/step - loss: 0.0167 - accuracy: 0.9024\n",
      "Epoch 2/10\n",
      "2500/2500 [==============================] - 2s 656us/step - loss: 0.0072 - accuracy: 0.9571\n",
      "Epoch 3/10\n",
      "2500/2500 [==============================] - 2s 633us/step - loss: 0.0053 - accuracy: 0.9693\n",
      "Epoch 4/10\n",
      "2500/2500 [==============================] - 2s 641us/step - loss: 0.0043 - accuracy: 0.9757\n",
      "Epoch 5/10\n",
      "2500/2500 [==============================] - 2s 741us/step - loss: 0.0036 - accuracy: 0.9797\n",
      "Epoch 6/10\n",
      "2500/2500 [==============================] - 2s 932us/step - loss: 0.0031 - accuracy: 0.9831\n",
      "Epoch 7/10\n",
      "2500/2500 [==============================] - 2s 905us/step - loss: 0.0027 - accuracy: 0.9846\n",
      "Epoch 8/10\n",
      "2500/2500 [==============================] - 2s 904us/step - loss: 0.0025 - accuracy: 0.9862\n",
      "Epoch 9/10\n",
      "2500/2500 [==============================] - 2s 895us/step - loss: 0.0022 - accuracy: 0.9884\n",
      "Epoch 10/10\n",
      "2500/2500 [==============================] - 2s 920us/step - loss: 0.0020 - accuracy: 0.9888\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1ee0ef92580>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myANN = Sequential()\n",
    "myANN.add(Dense(80,input_dim=784,activation='relu'))\n",
    "myANN.add(Dense(40,activation='relu'))\n",
    "myANN.add(Dense(10,activation='sigmoid'))\n",
    "myANN.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])\n",
    "myANN.fit(XTrain, YTrain, batch_size=24, epochs=10, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test score: 0.0040383106097579\n",
      "Test accuracy: 0.9768999814987183\n"
     ]
    }
   ],
   "source": [
    "score = myANN.evaluate(XTest, YTest, verbose=False)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28, 1)\n",
      "60000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "x_train = x_train / 255\n",
    "x_test = x_test / 255\n",
    "x_train = np.expand_dims(x_train, -1)\n",
    "x_test = np.expand_dims(x_test, -1)\n",
    "\n",
    "\n",
    "# Klassenvektoren in binäre Klaasenmatrizen\n",
    "y_train = keras.utils.to_categorical(y_train, 10)\n",
    "y_test = keras.utils.to_categorical(y_test, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 26, 26, 32)        320       \n",
      "_________________________________________________________________\n",
      "max_pooling2d (MaxPooling2D) (None, 13, 13, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 11, 11, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 1600)              0         \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 1600)              0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 10)                16010     \n",
      "=================================================================\n",
      "Total params: 34,826\n",
      "Trainable params: 34,826\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential(\n",
    "    [\n",
    "        keras.Input(shape=(28, 28, 1)),\n",
    "        layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\"),\n",
    "        layers.MaxPooling2D(pool_size=(2, 2)),\n",
    "        layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\"),\n",
    "        layers.MaxPooling2D(pool_size=(2, 2)),\n",
    "        layers.Flatten(),\n",
    "        layers.Dropout(0.5),\n",
    "        layers.Dense(num_classes, activation=\"softmax\"),\n",
    "    ]\n",
    ")\n",
    "\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "422/422 [==============================] - 25s 59ms/step - loss: 0.3593 - accuracy: 0.8900 - val_loss: 0.0763 - val_accuracy: 0.9803\n",
      "Epoch 2/15\n",
      "422/422 [==============================] - 26s 62ms/step - loss: 0.1079 - accuracy: 0.9672 - val_loss: 0.0555 - val_accuracy: 0.9845\n",
      "Epoch 3/15\n",
      "422/422 [==============================] - 29s 69ms/step - loss: 0.0818 - accuracy: 0.9746 - val_loss: 0.0455 - val_accuracy: 0.9877\n",
      "Epoch 4/15\n",
      "422/422 [==============================] - 30s 70ms/step - loss: 0.0696 - accuracy: 0.9786 - val_loss: 0.0423 - val_accuracy: 0.9888\n",
      "Epoch 5/15\n",
      "422/422 [==============================] - 28s 65ms/step - loss: 0.0621 - accuracy: 0.9804 - val_loss: 0.0381 - val_accuracy: 0.9895\n",
      "Epoch 6/15\n",
      "422/422 [==============================] - 27s 63ms/step - loss: 0.0552 - accuracy: 0.9831 - val_loss: 0.0342 - val_accuracy: 0.9903\n",
      "Epoch 7/15\n",
      "422/422 [==============================] - 27s 64ms/step - loss: 0.0513 - accuracy: 0.9839 - val_loss: 0.0337 - val_accuracy: 0.9900\n",
      "Epoch 8/15\n",
      "422/422 [==============================] - 32s 77ms/step - loss: 0.0468 - accuracy: 0.9852 - val_loss: 0.0315 - val_accuracy: 0.9910\n",
      "Epoch 9/15\n",
      "422/422 [==============================] - 29s 69ms/step - loss: 0.0448 - accuracy: 0.9857 - val_loss: 0.0318 - val_accuracy: 0.9910\n",
      "Epoch 10/15\n",
      "422/422 [==============================] - 29s 69ms/step - loss: 0.0413 - accuracy: 0.9868 - val_loss: 0.0323 - val_accuracy: 0.9910\n",
      "Epoch 11/15\n",
      "422/422 [==============================] - 28s 66ms/step - loss: 0.0396 - accuracy: 0.9870 - val_loss: 0.0292 - val_accuracy: 0.9923\n",
      "Epoch 12/15\n",
      "422/422 [==============================] - 28s 67ms/step - loss: 0.0379 - accuracy: 0.9881 - val_loss: 0.0322 - val_accuracy: 0.9903\n",
      "Epoch 13/15\n",
      "422/422 [==============================] - 27s 64ms/step - loss: 0.0363 - accuracy: 0.9886 - val_loss: 0.0277 - val_accuracy: 0.9918\n",
      "Epoch 14/15\n",
      "422/422 [==============================] - 26s 62ms/step - loss: 0.0342 - accuracy: 0.9891 - val_loss: 0.0302 - val_accuracy: 0.9908\n",
      "Epoch 15/15\n",
      "422/422 [==============================] - 26s 61ms/step - loss: 0.0334 - accuracy: 0.9888 - val_loss: 0.0331 - val_accuracy: 0.9898\n",
      "Test loss: 0.026835501194000244\n",
      "Test accuracy: 0.9919000267982483\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
    "\n",
    "model.fit(x_train, y_train, batch_size=128, epochs=15, validation_split=0.1)\n",
    "score = model.evaluate(x_test, y_test, verbose=0)\n",
    "print(\"Test loss:\", score[0])\n",
    "print(\"Test accuracy:\", score[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from tensorflow import keras\n",
    "from keras.datasets import mnist\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "(XTrain, yTrain), (XTest, yTest) = mnist.load_data()\n",
    "\n",
    "# Umwalndlung in Vektoren\n",
    "XTrain = XTrain.reshape(60000, 784)\n",
    "XTest = XTest.reshape(10000, 784)\n",
    "# Skalierung durch Dision durch 255\n",
    "XTrain = XTrain/255\n",
    "XTest = XTest/255\n",
    "\n",
    "knn=KNeighborsClassifier(n_neighbors=20)\n",
    "knn.fit(XTrain, yTrain)\n",
    "knn.score(XTest, yTest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resultate\n",
    "## Fully Connected Netz\n",
    "Es wurden drei Layer erstellt. Die erste mit 80 Konten, die zweite mit 40, und die dritte mit 10.\n",
    "Für die ersten bdieden wurde relu Funktion verwendet, für die letzte die sigmoid.\n",
    "Das fully Connected Netz führt zu einer Genauigkeit von ~97.7% mit einem Loss von 0.004.\n",
    "## CNN\n",
    "Für CNN wurden vier Layer verwendet, je zwei Conv2D und und zwei MaxPooling2D. Am Ende wurden noch flatten, dropout und dense Layers verwendet um die Daten zu strukturieren.\n",
    "Mit dem CNN haben wir eine Genauigkeit von ~99.2% mit einem Loss von 0.026\n",
    "## KNN\n",
    "Mit KNN und 10 Nachbarn wurde eine Genauigkeit von 96.65% erreicht. Der Loss ist leider nicht ersichtlich.\n",
    "\n",
    "## Vergleich\n",
    "CNN hat die beste Genauigkeit, welche mit 99.2% enorm hoch ist. Das fully connected Netz hat eine etwas tiefere Genauigkeit, aber ein tieferer Loss. Wobei der Loss bei CNN auch nicht hoch ist. Die Genauigkeit von KNN lässt zu wünschen übrig, dies liegt aber auch an der tiefen Anzahl von Nachbarn, welche gewählt wurde."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}