nb_ex3_1_dnn_mnist_cl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 필기체를 분류하는 DNN 구현\n",
    "4단계로 은닉 계층이 늘어난 DNN을 케라스로 구현합니다.\n",
    "\n",
    "### 3.2.1 기본 파라미터 설정 \n",
    "이 절에서는 4단계로 은닉 계층이 늘어난 DNN을 케라스로 구현합니다.\n",
    "\n",
    "#### 3.2.1 기본 파라미터 설정\n",
    " 1. DNN 구현에 필요한 파라미터를 정의합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "Nin = 784\n",
    "Nh_l = [100, 50]\n",
    "number_of_class = 10\n",
    "Nout = number_of_class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2 DNN 모델 구현\n",
    "2. 필기체 분류를 위한 DNN 모델을 구현합니다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import layers, models\n",
    " \n",
    "class DNN(models.Sequential):\n",
    "    def __init__(self, Nin, Nh_l, Nout):\n",
    "        super().__init__()\n",
    "        self.add(layers.Dense(Nh_l[0], activation='relu', input_shape=(Nin,), name='Hidden-1'))\n",
    "        self.add(layers.Dense(Nh_l[1], activation='relu', name='Hidden-2'))       \n",
    "        self.add(layers.Dense(Nout, activation='softmax'))\n",
    "        self.compile(loss='categorical_crossentropy', \n",
    "                         optimizer='adam', \n",
    "                         metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3 데이터 준비\n",
    "3. 분류 DNN을 위한 데이터 준비는 2.2.2절 ‘분류 ANN에 사용할 데이터 불러오기’와 같습니다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "from keras import datasets              \n",
    "from keras.utils import np_utils \n",
    " \n",
    "def Data_func():\n",
    "    (X_train, y_train), (X_test, y_test) = datasets.mnist.load_data()\n",
    "\n",
    "    Y_train = np_utils.to_categorical(y_train)\n",
    "    Y_test = np_utils.to_categorical(y_test)\n",
    "\n",
    "    L, W, H = X_train.shape\n",
    "    X_train = X_train.reshape(-1, W * H)\n",
    "    X_test = X_test.reshape(-1, W * H)\n",
    "\n",
    "    X_train = X_train / 255.0\n",
    "    X_test = X_test / 255.0\n",
    "\n",
    "    return (X_train, Y_train), (X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.4 학습 및 성능 평가\n",
    "4. 다음은 학습과 성능 평가 단계입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.3798 - accuracy: 0.8917 - val_loss: 0.1816 - val_accuracy: 0.9493\n",
      "Epoch 2/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.1568 - accuracy: 0.9536 - val_loss: 0.1361 - val_accuracy: 0.9594\n",
      "Epoch 3/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.1127 - accuracy: 0.9669 - val_loss: 0.1140 - val_accuracy: 0.9678\n",
      "Epoch 4/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.0864 - accuracy: 0.9742 - val_loss: 0.1032 - val_accuracy: 0.9713\n",
      "Epoch 5/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.0669 - accuracy: 0.9806 - val_loss: 0.1036 - val_accuracy: 0.9681\n",
      "100/100 [==============================] - 0s 3ms/step - loss: 0.0929 - accuracy: 0.9722\n",
      "Test Loss and Accuracy -> [0.0929151177406311, 0.9721999764442444]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from keraspp.skeras import plot_loss, plot_acc\n",
    "\n",
    "model = DNN(Nin, Nh_l, Nout)\n",
    "(X_train, Y_train), (X_test, Y_test) = Data_func()\n",
    "\n",
    "history = model.fit(X_train, Y_train, epochs=5, batch_size=100, validation_split=0.2)\n",
    "performace_test = model.evaluate(X_test, Y_test, batch_size=100)\n",
    "print('Test Loss and Accuracy ->', performace_test)\n",
    "\n",
    "plot_loss(history)\n",
    "plt.show()\n",
    "plot_acc(history)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3.2.5 전체 코드 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-09-21 17:26:36.865287: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1\n",
      "2021-09-21 17:26:37.089423: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.089572: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1561] Found device 0 with properties: \n",
      "pciBusID: 0000:01:00.0 name: NVIDIA GeForce GTX 1050 computeCapability: 6.1\n",
      "coreClock: 1.455GHz coreCount: 5 deviceMemorySize: 2.00GiB deviceMemoryBandwidth: 104.43GiB/s\n",
      "2021-09-21 17:26:37.089789: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1\n",
      "2021-09-21 17:26:37.091210: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10\n",
      "2021-09-21 17:26:37.092402: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10\n",
      "2021-09-21 17:26:37.092634: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10\n",
      "2021-09-21 17:26:37.094270: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10\n",
      "2021-09-21 17:26:37.095024: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10\n",
      "2021-09-21 17:26:37.098361: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7\n",
      "2021-09-21 17:26:37.099290: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.100192: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.100343: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1703] Adding visible gpu devices: 0\n",
      "2021-09-21 17:26:37.101142: I tensorflow/core/platform/cpu_feature_guard.cc:143] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "2021-09-21 17:26:37.107561: I tensorflow/core/platform/profile_utils/cpu_utils.cc:102] CPU Frequency: 3599995000 Hz\n",
      "2021-09-21 17:26:37.108398: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x56269866ccd0 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n",
      "2021-09-21 17:26:37.108418: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version\n",
      "2021-09-21 17:26:37.109391: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.109616: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1561] Found device 0 with properties: \n",
      "pciBusID: 0000:01:00.0 name: NVIDIA GeForce GTX 1050 computeCapability: 6.1\n",
      "coreClock: 1.455GHz coreCount: 5 deviceMemorySize: 2.00GiB deviceMemoryBandwidth: 104.43GiB/s\n",
      "2021-09-21 17:26:37.109691: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1\n",
      "2021-09-21 17:26:37.109716: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10\n",
      "2021-09-21 17:26:37.109739: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10\n",
      "2021-09-21 17:26:37.109751: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10\n",
      "2021-09-21 17:26:37.109764: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10\n",
      "2021-09-21 17:26:37.109776: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10\n",
      "2021-09-21 17:26:37.109790: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7\n",
      "2021-09-21 17:26:37.110452: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.111254: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.111490: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1703] Adding visible gpu devices: 0\n",
      "2021-09-21 17:26:37.111569: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1\n",
      "2021-09-21 17:26:37.324211: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1102] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2021-09-21 17:26:37.324244: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1108]      0 \n",
      "2021-09-21 17:26:37.324252: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1121] 0:   N \n",
      "2021-09-21 17:26:37.325083: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.325209: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1330] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.\n",
      "2021-09-21 17:26:37.325757: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.326352: E tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:967] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2021-09-21 17:26:37.326506: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1247] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 1421 MB memory) -> physical GPU (device: 0, name: NVIDIA GeForce GTX 1050, pci bus id: 0000:01:00.0, compute capability: 6.1)\n",
      "2021-09-21 17:26:37.328704: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x56269c218940 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2021-09-21 17:26:37.328731: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce GTX 1050, Compute Capability 6.1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "  1/480 [..............................] - ETA: 0s - loss: 2.3828 - accuracy: 0.1200"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-09-21 17:26:39.065867: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "480/480 [==============================] - 3s 5ms/step - loss: 0.3757 - accuracy: 0.8942 - val_loss: 0.1889 - val_accuracy: 0.9469\n",
      "Epoch 2/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.1615 - accuracy: 0.9521 - val_loss: 0.1384 - val_accuracy: 0.9591\n",
      "Epoch 3/5\n",
      "480/480 [==============================] - 3s 5ms/step - loss: 0.1133 - accuracy: 0.9664 - val_loss: 0.1181 - val_accuracy: 0.9656\n",
      "Epoch 4/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.0880 - accuracy: 0.9737 - val_loss: 0.1083 - val_accuracy: 0.9675\n",
      "Epoch 5/5\n",
      "480/480 [==============================] - 2s 5ms/step - loss: 0.0693 - accuracy: 0.9790 - val_loss: 0.0965 - val_accuracy: 0.9727\n",
      "100/100 [==============================] - 0s 3ms/step - loss: 0.0876 - accuracy: 0.9730\n",
      "Test Loss and Accuracy -> [0.087553009390831, 0.9729999899864197]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# File: ex3_1_dnn_mnist_cl.py\n",
    "\n",
    "# 1. 기본 파라미터 설정\n",
    "Nin = 784\n",
    "Nh_l = [100, 50]\n",
    "number_of_class = 10\n",
    "Nout = number_of_class\n",
    " \n",
    "# 1. 분류 DNN 모델 구현 \n",
    "from keras import layers, models\n",
    " \n",
    "class DNN(models.Sequential):\n",
    "    def __init__(self, Nin, Nh_l, Nout):\n",
    "        super().__init__()\n",
    "        self.add(layers.Dense(Nh_l[0], activation='relu', input_shape=(Nin,), name='Hidden-1'))\n",
    "        self.add(layers.Dense(Nh_l[1], activation='relu', name='Hidden-2'))       \n",
    "        self.add(layers.Dense(Nout, activation='softmax'))\n",
    "        self.compile(loss='categorical_crossentropy', \n",
    "                         optimizer='adam', \n",
    "                         metrics=['accuracy'])\n",
    "        \n",
    "# 3. 데이터 준비\n",
    "import numpy as np \n",
    "from keras import datasets              \n",
    "from keras.utils import np_utils \n",
    " \n",
    "def Data_func():\n",
    "    (X_train, y_train), (X_test, y_test) = datasets.mnist.load_data()\n",
    "\n",
    "    Y_train = np_utils.to_categorical(y_train)\n",
    "    Y_test = np_utils.to_categorical(y_test)\n",
    "\n",
    "    L, W, H = X_train.shape\n",
    "    X_train = X_train.reshape(-1, W * H)\n",
    "    X_test = X_test.reshape(-1, W * H)\n",
    "\n",
    "    X_train = X_train / 255.0\n",
    "    X_test = X_test / 255.0\n",
    "\n",
    "    return (X_train, Y_train), (X_test, Y_test)\n",
    " \n",
    "# 4. 분류 DNN 학습 및 테스팅 \n",
    "import matplotlib.pyplot as plt\n",
    "from keraspp.skeras import plot_loss, plot_acc\n",
    "\n",
    "def main():\n",
    "    model = DNN(Nin, Nh_l, Nout)\n",
    "    (X_train, Y_train), (X_test, Y_test) = Data_func()\n",
    "\n",
    "    history = model.fit(X_train, Y_train, epochs=5, batch_size=100, validation_split=0.2)\n",
    "    performace_test = model.evaluate(X_test, Y_test, batch_size=100)\n",
    "    print('Test Loss and Accuracy ->', performace_test)\n",
    "\n",
    "    plot_loss(history)\n",
    "    plt.show()\n",
    "    plot_acc(history)\n",
    "    plt.show()\n",
    "    \n",
    "main()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "keras-gpu",
   "language": "python",
   "name": "keras-gpu"
  },
  "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"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}