new_keras_cnn_神魔之塔-optimized-restore-model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Runestone recognition of the Tower of Saviors \n",
    "神魔之塔之符石的影像辨識"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "import keras\n",
    "import numpy as np\n",
    "from keras.datasets import mnist\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras import backend as K\n",
    "from scipy import misc\n",
    "from numpy import genfromtxt\n",
    "import csv\n",
    "from keras import utils as np_utils #自己多加的\n",
    "batch_size = 32\n",
    "num_classes = 7#原本是6\n",
    "epochs = 20 #原本是20\n",
    "file_num = 28    #  原本15個 folder\n",
    "test_num = 30    #  測試幾個image 原本是30\n",
    "test_index = 29 #   測試第幾個folder\n",
    "test_index2 = 30\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 載入訓練資料與測試資料\n",
    "Loading training data and testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\s9021\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imread`` instead.\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "x_train = []\n",
    "print(type(x_train))\n",
    "for ii in range(0,file_num):\n",
    "     for i in range(0,30):\n",
    "            filename = \"c://test/img_out/\"+str(ii)+\"/\"+str(int(i/6)) + str(i%6) + \".jpg\"\n",
    "            #print(filename)\n",
    "            image = misc.imread(filename)\n",
    "            x_train = np.append(x_train, image)\n",
    "            \n",
    "#print(x_train) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\s9021\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:4: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imread`` instead.\n",
      "  after removing the cwd from sys.path.\n",
      "C:\\Users\\s9021\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:10: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imread`` instead.\n",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    }
   ],
   "source": [
    "x_test = []\n",
    "for i in range(0,test_num):\n",
    "    filename = \"c://test/img_out/\"+str(test_index)+\"/\"+str(int(i/6)) + str(i%6) + \".jpg\"\n",
    "    image = misc.imread(filename)\n",
    "    x_test = np.append(x_test, image)\n",
    "    #print(filename)\n",
    " \n",
    "for j in range(0,test_num):\n",
    "    filename = \"c://test/img_out/\"+str(test_index2)+\"/\"+str(int(j/6)) + str(j%6) + \".jpg\"\n",
    "    image = misc.imread(filename)\n",
    "    x_test = np.append(x_test, image)\n",
    "    #print(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 載入訓練資料與測試資料的標籤\n",
    "Load the label of training data and test data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = []\n",
    "\n",
    "for ii in range(0,file_num):\n",
    "    filename = \"c://test/img_out/\"+str(ii)+\"/label.csv\"\n",
    "    #print(filename) \n",
    "    with open(filename) as myFile:  \n",
    "       reader = csv.reader(myFile,lineterminator='\\n')\n",
    "       for row in reader:\n",
    "          y_train =   np.append(y_train, row)\n",
    "      \n",
    "#print(y_train) \n",
    "#type(y_train)\n",
    "#a=['1' '2']\n",
    "#type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = \"c://test/img_out/\"+str(test_index)+\"/label.csv\"\n",
    "y_test = []\n",
    "y_test_tmp = []\n",
    "with open(filename) as myFile:  \n",
    "       reader = csv.reader(myFile,lineterminator='\\n')\n",
    "       for row in reader:\n",
    "          y_test_tmp =   np.append(y_test_tmp, row)\n",
    "          \n",
    "for i in range(0,test_num):\n",
    "    y_test = np.append(y_test, y_test_tmp[i])\n",
    "    #print(filename)\n",
    "#print(y_test)\n",
    "\n",
    "filename2 = \"c://test/img_out/\"+str(test_index2)+\"/label.csv\"\n",
    "#y_test2 = []\n",
    "y_test_tmp2 = []\n",
    "with open(filename2) as myFile:  \n",
    "       reader = csv.reader(myFile,lineterminator='\\n')\n",
    "       for row in reader:\n",
    "          y_test_tmp2 =   np.append(y_test_tmp2, row)\n",
    "          \n",
    "for i in range(0,test_num):\n",
    "    y_test = np.append(y_test, y_test_tmp2[i])\n",
    "    #print(filename)\n",
    "#print(y_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# reshape維度\n",
    "Reshape the dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_rows, img_cols = 28, 28 #已經二值化 加大沒差\n",
    "x_train = x_train.reshape(file_num*30, img_rows, img_cols, 1)#CNN要的是空間和影像關係->轉二維\n",
    "x_test = x_test.reshape(60, img_rows, img_cols, 1)\n",
    "input_shape = (img_rows, img_cols, 1)\n",
    "#從原本4維變3維\n",
    "x_test_copy = x_test.reshape(60, img_rows, img_cols)#未正規化前多存一份x_test_copy,方便看以後哪裡有問題可以show"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 正規化\n",
    "Normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (840, 28, 28, 1)\n",
      "840 train samples\n",
      "60 test samples\n"
     ]
    }
   ],
   "source": [
    "x_train = x_train.astype('float32')\n",
    "x_test = x_test.astype('float32')#轉浮點數\n",
    "x_train /= 255#正規化\n",
    "x_test /= 255\n",
    "print('x_train shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples') #TRAIN的數目\n",
    "print(x_test.shape[0], 'test samples') #TEST的數目 \n",
    "# convert class vectors to binary class matrices\n",
    "\n",
    "y_test_categories = y_test#y_test未做one-hot前先備份\n",
    "\n",
    "y_train = keras.utils.to_categorical(y_train, num_classes) #做one-hot encoding \n",
    "y_test = keras.utils.to_categorical(y_test, num_classes)\n",
    "#xx=['0','1','2','3','4','5','6','7','8','9']\n",
    "#xx=keras.utils.to_categorical(xx, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 建立Sequential模型並訓練 (4層convolution)\n",
    "Build the Sequential model and train(4-layer convolution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 840 samples, validate on 60 samples\n",
      "Epoch 1/15\n",
      "840/840 [==============================] - 6s 7ms/step - loss: 1.8295 - acc: 0.2357 - val_loss: 1.8033 - val_acc: 0.2000\n",
      "Epoch 2/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 1.5961 - acc: 0.3702 - val_loss: 1.2474 - val_acc: 0.5667\n",
      "Epoch 3/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 1.0342 - acc: 0.6702 - val_loss: 0.7308 - val_acc: 0.8000\n",
      "Epoch 4/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 0.6577 - acc: 0.8262 - val_loss: 0.4423 - val_acc: 0.8833\n",
      "Epoch 5/15\n",
      "840/840 [==============================] - 4s 5ms/step - loss: 0.4337 - acc: 0.8774 - val_loss: 0.4634 - val_acc: 0.8500\n",
      "Epoch 6/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 0.3344 - acc: 0.9071 - val_loss: 0.2081 - val_acc: 0.9167\n",
      "Epoch 7/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 0.2222 - acc: 0.9286 - val_loss: 0.1611 - val_acc: 0.9667\n",
      "Epoch 8/15\n",
      "840/840 [==============================] - 5s 5ms/step - loss: 0.1265 - acc: 0.9512 - val_loss: 0.1104 - val_acc: 0.9667\n",
      "Epoch 9/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 0.0981 - acc: 0.9679 - val_loss: 0.0786 - val_acc: 0.9667\n",
      "Epoch 10/15\n",
      "840/840 [==============================] - 5s 5ms/step - loss: 0.0757 - acc: 0.9762 - val_loss: 0.0972 - val_acc: 0.9667\n",
      "Epoch 11/15\n",
      "840/840 [==============================] - 5s 5ms/step - loss: 0.0769 - acc: 0.9726 - val_loss: 0.0877 - val_acc: 0.9667\n",
      "Epoch 12/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 0.0430 - acc: 0.9845 - val_loss: 0.1355 - val_acc: 0.9500\n",
      "Epoch 13/15\n",
      "840/840 [==============================] - 5s 6ms/step - loss: 0.0566 - acc: 0.9821 - val_loss: 0.0793 - val_acc: 0.9667\n",
      "Epoch 14/15\n",
      "840/840 [==============================] - 4s 5ms/step - loss: 0.0337 - acc: 0.9905 - val_loss: 0.1717 - val_acc: 0.9667\n",
      "Epoch 15/15\n",
      "840/840 [==============================] - 4s 5ms/step - loss: 0.0294 - acc: 0.9952 - val_loss: 0.0864 - val_acc: 0.9667\n",
      "Test loss: 0.0864271933833758\n",
      "Test accuracy: 0.9666666746139526\n"
     ]
    }
   ],
   "source": [
    "from keras import optimizers#之前優化的結果用在這試看看 ->4層 convolution變大 , optimizer變sgd\n",
    "from keras.layers import Activation\n",
    "\n",
    "epochs = 15\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Conv2D(32, (3, 3), padding='same',\n",
    "                 input_shape=x_train.shape[1:]))\n",
    "model.add(Activation('relu'))\n",
    "model.add(Conv2D(32, (3, 3)))\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "model.add(Conv2D(64, (3, 3), padding='same'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(Conv2D(64, (3, 3)))\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(512))\n",
    "model.add(Activation('relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(num_classes))\n",
    "model.add(Activation('softmax'))\n",
    "\n",
    "sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)\n",
    "\n",
    "\n",
    "model.compile(loss=keras.losses.categorical_crossentropy,\n",
    "              optimizer=sgd,\n",
    "              metrics=['accuracy'])\n",
    "history2=model.fit(x_train, y_train,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test))\n",
    "score1 = model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss:', score1[0])\n",
    "print('Test accuracy:', score1[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Training data')\n",
    "plt.plot(history2.history['acc'])\n",
    "plt.plot(history2.history['val_acc'])\n",
    "plt.legend(['training','validation'],loc='lower right')\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training data')\n",
    "plt.plot(history2.history['loss'])\n",
    "plt.plot(history2.history['val_loss'])\n",
    "plt.legend(['training','validation'],loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 混淆矩陣Confusion matrix\n",
    "Confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>predict</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>label</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "predict   1  2  3  4  5  6\n",
       "label                     \n",
       "1        18  0  0  2  0  0\n",
       "2         0  7  0  0  0  0\n",
       "3         0  0  9  0  0  0\n",
       "4         0  0  0  7  0  0\n",
       "5         0  0  0  0  9  0\n",
       "6         0  0  0  0  0  8"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "prediction = model.predict_classes(x_test)\n",
    "pd.crosstab(y_test_categories, prediction, rownames=['label'], colnames=['predict'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60, 2)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>predict</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>59</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   label  predict\n",
       "29     1        4\n",
       "59     1        4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame( {'label':y_test_categories, 'predict':prediction} )\n",
    "print(df.shape)\n",
    "#df[:2]\n",
    "df[(df.label=='1')&(df.predict==4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 顯示預測錯誤的符石\n",
    "Shows the Runestone that is predicted to be wrong"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "# Plot inline\n",
    "get_ipython().magic('matplotlib inline')\n",
    "def plot_image(image):\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(2, 2)\n",
    "    plt.imshow(image, cmap='binary')\n",
    "    plt.show()\n",
    "\n",
    "plot_image(x_test_copy[29]) \n",
    "plot_image(x_test_copy[59])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 將模型匯出成JSON，並將weights匯出成HDF5\n",
    "Export the model into a JSON file and export the weights to HDF5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# serialize model to JSON\n",
    "model_json = model.to_json()\n",
    "with open(\"c://test/final_model_new.json\", \"w\") as json_file:\n",
    "    json_file.write(model_json)\n",
    "    \n",
    "model.save_weights('c://test/final_model_weights_new.h5') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import model_from_json\n",
    "json_file = open('c://test/final_model.json', 'r')\n",
    "loaded_model_json = json_file.read()\n",
    "json_file.close()\n",
    "loaded_model = model_from_json(loaded_model_json)\n",
    "# load weights into new model\n",
    "loaded_model.load_weights(\"c://test/final_model_weights.h5\")\n",
    "print(\"Loaded model from disk\")\n",
    "loaded_model.compile(loss='categorical_crossentropy', optimizer='adam',metrics=['accuracy'])\n",
    "score2 = loaded_model.evaluate(x_test, y_test,verbose=0)\n",
    "print('Test loss:', score2[0])\n",
    "print('Test accuracy:', score2[1])"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}