nb_ex_1_rnn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5장. 케라스2로 구현하는 RNN(순환신경망)\n",
    "## 5.2 문장을 판별하는 LSTM 구현\n",
    "LSTM을 이용하여 문장의 의미를 이해하는 예제를 구현합\n",
    "### 5.2.1 라이브러리 임포트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set to use CPU\n",
    "import osㅊ\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 필요한 패키지들을 임포트합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 유용한 기능을 제공하는 다른 파이썬 패키지도 임포트합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 케라스 모델링을 위한 서브패키지들을 불러옵니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import backend as K\n",
    "from keras.utils import np_utils\n",
    "from keras.models import Model\n",
    "from keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 케라스를 편리하게 사용하기 위해 여기서 만든 2가지 모듈을 불러옵니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keraspp import skeras\n",
    "from keraspp import sfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.2 분류 CNN 모델링"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 분류 CNN 모델링을 만듭니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. 분류 CNN 모델링\n",
    "class CNN(Model):\n",
    "    def __init__(self, nb_classes): \n",
    "        super(CNN,self).__init__() \n",
    "        self.nb_classes = nb_classes\n",
    "        \n",
    "        self.conv2D_A = Conv2D(32, kernel_size=(3, 3), activation='relu')\n",
    "        self.conv2D_B = Conv2D(64, (3, 3), activation='relu')\n",
    "        self.maxPooling2D_A = MaxPooling2D(pool_size=(2, 2))\n",
    "        self.dropout_A = Dropout(0.25)\n",
    "        self.flatten = Flatten()\n",
    "        \n",
    "        self.dense_A = Dense(128, activation='relu')\n",
    "        self.dropout_B = Dropout(0.5)\n",
    "        self.dense_B = Dense(nb_classes, activation='softmax', name='preds')\n",
    "        \n",
    "    def call(self, x):\n",
    "        h = self.conv2D_A(x)\n",
    "        h = self.conv2D_B(h)\n",
    "        h = self.maxPooling2D_A(h)\n",
    "        h = self.dropout_A(h)\n",
    "        h = self.flatten(h)\n",
    "\n",
    "        h = self.dense_A(h)\n",
    "        h = self.dropout_B(h)\n",
    "\n",
    "        y = self.dense_B(h)\n",
    "        \n",
    "        return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_classes = 10\n",
    "model = CNN(nb_classes=nb_classes)\n",
    "model.compile(loss='categorical_crossentropy',\n",
    "                      optimizer='adadelta', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.3 분류 CNN을 위한 데이터 준비"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 주어진 데이터를 해당 머신러닝에 사용하기 적합하도록 조정하는 기능을 하는 DataSet 클래스를 만듭니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. 분류 CNN을 위한 데이터 준비\n",
    "class DataSet:\n",
    "    def __init__(self, X, y, nb_classes, scaling=True, \n",
    "                 test_size=0.2, random_state=0):\n",
    "        self.X = X\n",
    "        self.add_channels()\n",
    "        X = self.X\n",
    "        \n",
    "        # the data, shuffled and split between train and test sets\n",
    "        X_train, X_test, y_train, y_test = model_selection.train_test_split(\n",
    "            X, y, test_size=0.2, random_state=random_state)\n",
    "\n",
    "        print(X_train.shape, y_train.shape)\n",
    "\n",
    "        X_train = X_train.astype('float32')\n",
    "        X_test = X_test.astype('float32')\n",
    "\n",
    "        if scaling:\n",
    "            # scaling to have (0, 1) for each feature (each pixel)\n",
    "            scaler = MinMaxScaler()\n",
    "            n = X_train.shape[0]\n",
    "            X_train = scaler.fit_transform(\n",
    "                X_train.reshape(n, -1)).reshape(X_train.shape)\n",
    "            n = X_test.shape[0]\n",
    "            X_test = scaler.transform(\n",
    "                X_test.reshape(n, -1)).reshape(X_test.shape)\n",
    "            self.scaler = scaler\n",
    "\n",
    "        print('X_train shape:', X_train.shape)\n",
    "        print(X_train.shape[0], 'train samples')\n",
    "        print(X_test.shape[0], 'test samples')\n",
    "\n",
    "        # convert class vectors to binary class matrices\n",
    "        Y_train = np_utils.to_categorical(y_train, nb_classes)\n",
    "        Y_test = np_utils.to_categorical(y_test, nb_classes)\n",
    "\n",
    "        self.X_train, self.X_test = X_train, X_test\n",
    "        self.Y_train, self.Y_test = Y_train, Y_test\n",
    "        self.y_train, self.y_test = y_train, y_test\n",
    "\n",
    "    def add_channels(self):\n",
    "        X = self.X\n",
    "\n",
    "        if len(X.shape) == 3:\n",
    "            N, img_rows, img_cols = X.shape\n",
    "\n",
    "            if K.image_dim_ordering() == 'th':\n",
    "                X = X.reshape(X.shape[0], 1, img_rows, img_cols)\n",
    "                input_shape = (1, img_rows, img_cols)\n",
    "            else:\n",
    "                X = X.reshape(X.shape[0], img_rows, img_cols, 1)\n",
    "                input_shape = (img_rows, img_cols, 1)\n",
    "        else:\n",
    "            input_shape = X.shape[1:]  # channel is already included.\n",
    "\n",
    "        self.X = X\n",
    "        self.input_shape = input_shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(40000, 32, 32, 3) (40000, 1)\n",
      "X_train shape: (40000, 32, 32, 3)\n",
      "40000 train samples\n",
      "10000 test samples\n",
      "data.input_shape (32, 32, 3)\n"
     ]
    }
   ],
   "source": [
    "from keras import datasets\n",
    "(X, y), (x_test, y_test) = datasets.cifar10.load_data()\n",
    "nb_classes = 10\n",
    "data = DataSet(X, y, nb_classes)\n",
    "print('data.input_shape', data.input_shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "313/313 [==============================] - 47s 150ms/step - loss: 2.3076 - accuracy: 0.1087 - val_loss: 2.2870 - val_accuracy: 0.1377\n",
      "Epoch 2/2\n",
      "313/313 [==============================] - 49s 158ms/step - loss: 2.2918 - accuracy: 0.1227 - val_loss: 2.2746 - val_accuracy: 0.1754\n"
     ]
    }
   ],
   "source": [
    "epochs=2\n",
    "batch_size=128\n",
    "verbose=1\n",
    "history = model.fit(data.X_train, data.Y_train, \n",
    "                    batch_size=batch_size, epochs=epochs,\n",
    "                    verbose=verbose, \n",
    "                    validation_data=(data.X_test, data.Y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.4 분류 CNN의 학습 및 성능 평가를 위한 머신 클래스"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. 학습 및 성능 평가를 쉽게 수행할 수 있는 상위 개념 클래스인 Machine을 만듭니다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4. 분류 CNN의 학습 및 성능 평가를 위한 머신 클래스\n",
    "class Machine():\n",
    "    def __init__(self, X, y, nb_classes=2, fig=True):\n",
    "        self.nb_classes = nb_classes\n",
    "        self.set_data(X, y)\n",
    "        self.set_model()\n",
    "        self.fig = fig\n",
    "\n",
    "    def set_data(self, X, y):\n",
    "        nb_classes = self.nb_classes\n",
    "        self.data = DataSet(X, y, nb_classes)\n",
    "        print('data.input_shape', self.data.input_shape)\n",
    "\n",
    "    def set_model(self):\n",
    "        nb_classes = self.nb_classes\n",
    "        data = self.data\n",
    "        self.model = CNN(nb_classes=nb_classes)\n",
    "        self.model.compile(loss='categorical_crossentropy',\n",
    "                      optimizer='adadelta', metrics=['accuracy'])        \n",
    "\n",
    "    def fit(self, epochs=10, batch_size=128, verbose=1):\n",
    "        data = self.data\n",
    "        model = self.model\n",
    "\n",
    "        history = model.fit(data.X_train, data.Y_train, \n",
    "                            batch_size=batch_size, epochs=epochs,\n",
    "                            verbose=verbose, \n",
    "                            validation_data=(data.X_test, data.Y_test))\n",
    "        return history\n",
    "\n",
    "    def run(self, epochs=100, batch_size=128, verbose=1):\n",
    "        data = self.data\n",
    "        model = self.model\n",
    "        fig = self.fig\n",
    "\n",
    "        history = self.fit(epochs=epochs,\n",
    "                           batch_size=batch_size, verbose=verbose)\n",
    "\n",
    "        score = model.evaluate(data.X_test, data.Y_test, verbose=0)\n",
    "\n",
    "        print('Confusion matrix')\n",
    "        Y_test_pred = model.predict(data.X_test, verbose=0)\n",
    "        y_test_pred = np.argmax(Y_test_pred, axis=1)\n",
    "        print(metrics.confusion_matrix(data.y_test, y_test_pred))\n",
    "\n",
    "        print('Test score:', score[0])\n",
    "        print('Test accuracy:', score[1])\n",
    "\n",
    "        # Save results\n",
    "        suffix = sfile.unique_filename('datatime')\n",
    "        foldname = 'output_' + suffix\n",
    "        os.makedirs(foldname)\n",
    "        skeras.save_history_history(\n",
    "            'history_history.npy', history.history, fold=foldname)\n",
    "        model.save_weights(os.path.join(foldname, 'dl_model.h5'))\n",
    "        print('Output results are saved in', foldname)\n",
    "\n",
    "        if fig:\n",
    "            plt.figure(figsize=(12, 4))\n",
    "            plt.subplot(1, 2, 1)\n",
    "            skeras.plot_acc(history)\n",
    "            plt.subplot(1, 2, 2)\n",
    "            skeras.plot_loss(history)\n",
    "            plt.show()\n",
    "\n",
    "        self.history = history\n",
    "\n",
    "        return foldname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 4.3.5 분류 CNN을 처리하는 머쉰의 전체 코드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# File - keraspp/aicnn.py\n",
    "\n",
    "# 1. 분류 CNN 패키지 임포트 \n",
    "from sklearn import model_selection, metrics\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "\n",
    "from keras import backend as K\n",
    "from keras.utils import np_utils\n",
    "from keras.models import Model\n",
    "from keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
    "\n",
    "from keraspp import skeras\n",
    "from keraspp import sfile\n",
    "\n",
    "# 2. 분류 CNN 모델링\n",
    "class CNN(Model):\n",
    "    def __init__(self, nb_classes): #, in_shape=None):\n",
    "        super(CNN,self).__init__() # added 2021-10-01\n",
    "        self.nb_classes = nb_classes\n",
    "        #self.in_shape = in_shape\n",
    "        \n",
    "        self.conv2D_A = Conv2D(32, kernel_size=(3, 3), activation='relu')\n",
    "        self.conv2D_B = Conv2D(64, (3, 3), activation='relu')\n",
    "        self.maxPooling2D_A = MaxPooling2D(pool_size=(2, 2))\n",
    "        self.dropout_A = Dropout(0.25)\n",
    "        self.flatten = Flatten()\n",
    "        \n",
    "        self.dense_A = Dense(128, activation='relu')\n",
    "        self.dropout_B = Dropout(0.5)\n",
    "        self.dense_B = Dense(nb_classes, activation='softmax', name='preds')\n",
    "        \n",
    "    def call(self, x):\n",
    "        nb_classes = self.nb_classes\n",
    "        # in_shape = self.in_shape\n",
    "\n",
    "        #x = Input(in_shape)\n",
    "\n",
    "        h = self.conv2D_A(x)\n",
    "        h = self.conv2D_B(h)\n",
    "        h = self.maxPooling2D_A(h)\n",
    "        h = self.dropout_A(h)\n",
    "        h = self.flatten(h)\n",
    "\n",
    "        h = self.dense_A(h)\n",
    "        h = self.dropout_B(h)\n",
    "\n",
    "        y = self.dense_B(h)\n",
    "        \n",
    "        return y\n",
    "\n",
    "# 3. 분류 CNN을 위한 데이터 준비\n",
    "class DataSet:\n",
    "    def __init__(self, X, y, nb_classes, scaling=True, \n",
    "                 test_size=0.2, random_state=0):\n",
    "        \"\"\"\n",
    "        X is originally vector. Hence, it will be transformed\n",
    "        to 2D images with a channel (i.e, 3D).\n",
    "        \"\"\"\n",
    "        self.X = X\n",
    "        self.add_channels()\n",
    "\n",
    "        X = self.X\n",
    "        # the data, shuffled and split between train and test sets\n",
    "        X_train, X_test, y_train, y_test = model_selection.train_test_split(\n",
    "            X, y, test_size=0.2, random_state=random_state)\n",
    "\n",
    "        print(X_train.shape, y_train.shape)\n",
    "\n",
    "        X_train = X_train.astype('float32')\n",
    "        X_test = X_test.astype('float32')\n",
    "\n",
    "        if scaling:\n",
    "            # scaling to have (0, 1) for each feature (each pixel)\n",
    "            scaler = MinMaxScaler()\n",
    "            n = X_train.shape[0]\n",
    "            X_train = scaler.fit_transform(\n",
    "                X_train.reshape(n, -1)).reshape(X_train.shape)\n",
    "            n = X_test.shape[0]\n",
    "            X_test = scaler.transform(\n",
    "                X_test.reshape(n, -1)).reshape(X_test.shape)\n",
    "            self.scaler = scaler\n",
    "\n",
    "        print('X_train shape:', X_train.shape)\n",
    "        print(X_train.shape[0], 'train samples')\n",
    "        print(X_test.shape[0], 'test samples')\n",
    "\n",
    "        # convert class vectors to binary class matrices\n",
    "        Y_train = np_utils.to_categorical(y_train, nb_classes)\n",
    "        Y_test = np_utils.to_categorical(y_test, nb_classes)\n",
    "\n",
    "        self.X_train, self.X_test = X_train, X_test\n",
    "        self.Y_train, self.Y_test = Y_train, Y_test\n",
    "        self.y_train, self.y_test = y_train, y_test\n",
    "        # self.input_shape = input_shape\n",
    "\n",
    "    def add_channels(self):\n",
    "        X = self.X\n",
    "\n",
    "        if len(X.shape) == 3:\n",
    "            N, img_rows, img_cols = X.shape\n",
    "\n",
    "            if K.image_dim_ordering() == 'th':\n",
    "                X = X.reshape(X.shape[0], 1, img_rows, img_cols)\n",
    "                input_shape = (1, img_rows, img_cols)\n",
    "            else:\n",
    "                X = X.reshape(X.shape[0], img_rows, img_cols, 1)\n",
    "                input_shape = (img_rows, img_cols, 1)\n",
    "        else:\n",
    "            input_shape = X.shape[1:]  # channel is already included.\n",
    "\n",
    "        self.X = X\n",
    "        self.input_shape = input_shape    \n",
    "    \n",
    "# 4. 분류 CNN의 학습 및 성능 평가를 위한 머신 클래스\n",
    "class Machine():\n",
    "    def __init__(self, X, y, nb_classes=2, fig=True):\n",
    "        self.nb_classes = nb_classes\n",
    "        self.set_data(X, y)\n",
    "        self.set_model()\n",
    "        self.fig = fig\n",
    "\n",
    "    def set_data(self, X, y):\n",
    "        nb_classes = self.nb_classes\n",
    "        self.data = DataSet(X, y, nb_classes)\n",
    "        print('data.input_shape', self.data.input_shape)\n",
    "\n",
    "    def set_model(self):\n",
    "        nb_classes = self.nb_classes\n",
    "        data = self.data\n",
    "        self.model = CNN(nb_classes=nb_classes)\n",
    "        self.model.compile(loss='categorical_crossentropy',\n",
    "                      optimizer='adadelta', metrics=['accuracy'])        \n",
    "\n",
    "    def fit(self, epochs=10, batch_size=128, verbose=1):\n",
    "        data = self.data\n",
    "        model = self.model\n",
    "\n",
    "        history = model.fit(data.X_train, data.Y_train, \n",
    "                            batch_size=batch_size, epochs=epochs,\n",
    "                            verbose=verbose, \n",
    "                            validation_data=(data.X_test, data.Y_test))\n",
    "        return history\n",
    "\n",
    "    def run(self, epochs=100, batch_size=128, verbose=1):\n",
    "        data = self.data\n",
    "        model = self.model\n",
    "        fig = self.fig\n",
    "\n",
    "        history = self.fit(epochs=epochs,\n",
    "                           batch_size=batch_size, verbose=verbose)\n",
    "\n",
    "        score = model.evaluate(data.X_test, data.Y_test, verbose=0)\n",
    "\n",
    "        print('Confusion matrix')\n",
    "        Y_test_pred = model.predict(data.X_test, verbose=0)\n",
    "        y_test_pred = np.argmax(Y_test_pred, axis=1)\n",
    "        print(metrics.confusion_matrix(data.y_test, y_test_pred))\n",
    "\n",
    "        print('Test score:', score[0])\n",
    "        print('Test accuracy:', score[1])\n",
    "\n",
    "        # Save results\n",
    "        suffix = sfile.unique_filename('datatime')\n",
    "        foldname = 'output_' + suffix\n",
    "        os.makedirs(foldname)\n",
    "        skeras.save_history_history(\n",
    "            'history_history.npy', history.history, fold=foldname)\n",
    "        model.save_weights(os.path.join(foldname, 'dl_model.h5'))\n",
    "        print('Output results are saved in', foldname)\n",
    "\n",
    "        if fig:\n",
    "            plt.figure(figsize=(12, 4))\n",
    "            plt.subplot(1, 2, 1)\n",
    "            skeras.plot_acc(history)\n",
    "            plt.subplot(1, 2, 2)\n",
    "            skeras.plot_loss(history)\n",
    "            plt.show()\n",
    "\n",
    "        self.history = history\n",
    "\n",
    "        return foldname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.6 분류 CNN의 학습 및 성능 평가 수행"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. 분류 CNN을 위한 머쉰에 기반하여 컬러 이미지를 분류합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5. 분류 CNN의 학습 및 성능 평가 수행\n",
    "from keras import datasets\n",
    "import keras\n",
    "assert keras.backend.image_data_format() == 'channels_last'\n",
    "\n",
    "# from keraspp import aicnn\n",
    "class MyMachine(Machine):\n",
    "    def __init__(self):\n",
    "        (X, y), (x_test, y_test) = datasets.cifar10.load_data()\n",
    "        super(MyMachine,self).__init__(X, y, nb_classes=10)\n",
    "\n",
    "def main():\n",
    "    m = MyMachine()\n",
    "    m.run(epochs=2)\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 4.3.7 분류 CNN의 수행을 위한 전체 코드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(40000, 32, 32, 3) (40000, 1)\n",
      "X_train shape: (40000, 32, 32, 3)\n",
      "40000 train samples\n",
      "10000 test samples\n",
      "data.input_shape (32, 32, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-10-02 10:40:34.941649: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1\n",
      "2021-10-02 10:40:35.254109: E tensorflow/stream_executor/cuda/cuda_driver.cc:313] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
      "2021-10-02 10:40:35.254269: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (SJKIM-Home): /proc/driver/nvidia/version does not exist\n",
      "2021-10-02 10:40:35.258540: 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-10-02 10:40:35.317358: I tensorflow/core/platform/profile_utils/cpu_utils.cc:102] CPU Frequency: 3599995000 Hz\n",
      "2021-10-02 10:40:35.318876: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x55b81145d7a0 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n",
      "2021-10-02 10:40:35.318943: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version\n",
      "2021-10-02 10:40:35.356906: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 491520000 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "313/313 [==============================] - 53s 169ms/step - loss: 2.3125 - accuracy: 0.1060 - val_loss: 2.2920 - val_accuracy: 0.1183\n",
      "Epoch 2/2\n",
      "313/313 [==============================] - 56s 179ms/step - loss: 2.2973 - accuracy: 0.1148 - val_loss: 2.2812 - val_accuracy: 0.1192\n",
      "Confusion matrix\n",
      "[[839   2   0   6   0   1   0   6 147   3]\n",
      " [621   0   0  12   1  11   0  19 309  13]\n",
      " [747   4   0   9   0  19   0  23 205   9]\n",
      " [576   4   0  38   0  46   0  33 325   8]\n",
      " [627   1   0  35   0  22   0  20 258   4]\n",
      " [642   1   0  28   0  29   0  28 280   8]\n",
      " [480   1   0  35   0  43   0  53 333   8]\n",
      " [682   3   0  15   0  22   1  28 231  17]\n",
      " [755   2   0   3   0   0   0   2 223   4]\n",
      " [726   8   0   1   0   8   0  10 252  35]]\n",
      "Test score: 2.281205415725708\n",
      "Test accuracy: 0.11919999867677689\n",
      "Output results are saved in output_37ca986a-8f98-4cab-9d67-89b863ea66e0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# File - ex4_2_cnn_ficar10_cl-cpu.py\n",
    "\n",
    "# set to use CPU\n",
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n",
    "\n",
    "# 5. 분류 CNN의 학습 및 성능 평가 수행\n",
    "from keras import datasets\n",
    "import keras\n",
    "assert keras.backend.image_data_format() == 'channels_last'\n",
    "from keraspp import aicnn\n",
    "\n",
    "# from keraspp import aicnn\n",
    "class MyMachine(aicnn.Machine):\n",
    "    def __init__(self):\n",
    "        (X, y), (x_test, y_test) = datasets.cifar10.load_data()\n",
    "        super(MyMachine,self).__init__(X, y, nb_classes=10)\n",
    "\n",
    "def main():\n",
    "    m = MyMachine()\n",
    "    m.run(epochs=2)\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
}