Diabetic_CNN_GPU_Accuracy68.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convolutional Neural Network (CNN) implementation for Diabetic Retinopathy Detection \n",
    "https://www.kaggle.com/c/diabetic-retinopathy-detection/data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import keras \n",
    "\n",
    "from tqdm import tqdm\n",
    "import os\n",
    "from sklearn.model_selection import train_test_split\n",
    "from cv2 import cv2\n",
    "from PIL import Image\n",
    "import tensorflow as tf\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from keras.layers import Dense, Dropout, Flatten, Input\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
    "from keras.preprocessing import image\n",
    "from keras.utils import plot_model\n",
    "from keras.models import Model\n",
    "from keras.layers.convolutional import Conv2D\n",
    "from keras.layers.pooling import MaxPooling2D\n",
    "from numpy import array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import tensorflow as tf\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "sess = tf.Session(config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I have already downloaded the dataset from Kaggle.\n",
    "I have noted all the steps to download the database in a seperate file.\n",
    "Below I am loading a CSV file containing training labels "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_csv('/storage/trainLabels.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets take a look at all the labels.\n",
    "'10_left' is a name of the file whereas '0/1/2/3/4' are the labels\n",
    "'10_left' image of the left eye\n",
    "'10_right' image of the right eye for the same person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['10_left', 0],\n",
       "       ['10_right', 0],\n",
       "       ['13_left', 0],\n",
       "       ...,\n",
       "       ['44348_right', 0],\n",
       "       ['44349_left', 0],\n",
       "       ['44349_right', 1]], dtype=object)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 35125 images in the training set, 'level' is the column indicating the labels for its respective images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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></th>\n",
       "      <th>image</th>\n",
       "      <th>level</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>35121</th>\n",
       "      <td>44347_right</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35122</th>\n",
       "      <td>44348_left</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35123</th>\n",
       "      <td>44348_right</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35124</th>\n",
       "      <td>44349_left</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35125</th>\n",
       "      <td>44349_right</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             image  level\n",
       "35121  44347_right      0\n",
       "35122   44348_left      0\n",
       "35123  44348_right      0\n",
       "35124   44349_left      0\n",
       "35125  44349_right      1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use Pandas to convert df_train into a series.\n",
    "and get_dummies to do one hot encoding (FYI, I am not using one hot encoding during training as of now)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "targets_series = pd.Series(df_train['level'])\n",
    "one_hot = pd.get_dummies(targets_series, sparse = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As I said before there are 5 types of labels 0/1/2/3/4, thry are distinguished as below\n",
    "NDPR - Non Proliferative Diabetic Retinopathy\n",
    "\n",
    "Class\t Name\n",
    "0\t    Normal\t\n",
    "1\t    Mild NPDR\n",
    "2\t    Moderate NPDR\n",
    "3\t    Severe NPDR\t\n",
    "4\t    PDR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "1    0\n",
       "2    0\n",
       "3    0\n",
       "4    1\n",
       "5    2\n",
       "6    4\n",
       "7    4\n",
       "8    0\n",
       "9    1\n",
       "Name: level, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "targets_series[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</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>1</td>\n",
       "      <td>0</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>1</td>\n",
       "      <td>0</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>1</td>\n",
       "      <td>0</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>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1  2  3  4\n",
       "0  1  0  0  0  0\n",
       "1  1  0  0  0  0\n",
       "2  1  0  0  0  0\n",
       "3  1  0  0  0  0\n",
       "4  0  1  0  0  0\n",
       "5  0  0  1  0  0\n",
       "6  0  0  0  0  1\n",
       "7  0  0  0  0  1\n",
       "8  1  0  0  0  0\n",
       "9  0  1  0  0  0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_hot_labels = np.asarray(one_hot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_hot_labelsY = np.asarray(targets_series)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets take a look at the array containing just the labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 1, 2, 4, 4, 0, 1])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot_labelsY[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some declarations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "im_size1 = 786\n",
    "im_size2 = 786"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = []\n",
    "y_train = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are interested to check all image names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = df_train[:20000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IF you plan to run this code on all 35125 images then replace df_test with df_train.\n",
    "This code sneppet will load all the images and labels into a numpy array.\n",
    "You can also load images using OpenCV, I will mention the code OpenCV code in comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"\"\"\n",
    "i = 0 \n",
    "for f, breed in tqdm(df_train.values):\n",
    "    if type(cv2.imread('/storage/train/{}.jpeg'.format(f)))==type(None):\n",
    "        continue\n",
    "    else:\n",
    "        img = cv2.imread('/storage/train/{}.jpeg'.format(f))\n",
    "        label = one_hot_labels[i]\n",
    "        x_train.append(cv2.resize(img, (im_size1, im_size2)))\n",
    "        y_train.append(label)\n",
    "        i += 1\n",
    "np.save('x_train2',x_train)\n",
    "np.save('y_train2',y_train)\n",
    "print('Done')\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20000/20000 [1:52:24<00:00,  1.47it/s]  \n"
     ]
    }
   ],
   "source": [
    "i=0\n",
    "for f, breed in tqdm(df_test.values):\n",
    "    try:\n",
    "        img = image.load_img(('/storage/train/{}.jpeg'.format(f)), target_size=(128, 128))\n",
    "        arr = image.img_to_array(img)\n",
    "        label = one_hot_labelsY[i]\n",
    "        x_train.append(arr)\n",
    "        y_train.append(label)\n",
    "        i += 1 \n",
    "    except:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets just verify one of the images from the numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f844c69cc50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(x_train[10011]/255)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Its important to split the whole dataset into training and validation dataset apart from testing dataset which we have seperately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_valid = []\n",
    "y_valid = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_valid, Y_train, Y_valid = train_test_split(x_train, y_train, test_size=0.1, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will define the model >>\n",
    "The model has 2 convolutional leyers, 2 max pooling layes, image flattening layer and a dence layer\n",
    "Models in Keras/TF come in 2 forms - Sequential (model = Sequential()) or using Funtional API\n",
    "Below code is using Funtional API which is usually used for complex models, i will leave the light weight Sequential() model in comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_raw = np.array(Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train_raw = np.array(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "visible = Input(shape=(128,128,3))\n",
    "conv6 = Conv2D(16, kernel_size=(12,12), activation='relu', padding='valid')(visible)\n",
    "pool3 = MaxPooling2D(pool_size=(2, 2))(conv6)\n",
    "#bat1 = BatchNormalization(axis = 1)(pool1)\n",
    "\n",
    "conv2 = Conv2D(64, kernel_size=(8,8), activation='relu', padding='valid')(pool3)\n",
    "conv3 = Conv2D(64, kernel_size=(4,4), activation='relu', padding='valid')(conv2)\n",
    "conv4 = Conv2D(128, kernel_size=(4,4), activation='relu', padding='valid')(conv3)\n",
    "conv5 = Conv2D(256, kernel_size=(4,4), activation='relu', padding='valid')(conv4)\n",
    "\n",
    "pool2 = MaxPooling2D(pool_size=(2, 2))(conv5)\n",
    "#pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\n",
    "flat = Flatten()(pool2)\n",
    "hidden1 = Dense(128, activation='relu')(flat)\n",
    "drop1 = Dropout(0.2)(hidden1)\n",
    "\n",
    "hidden2 = Dense(64, activation='relu')(drop1)\n",
    "drop2 = Dropout(0.2)(hidden2)\n",
    "output = Dense(5, activation='sigmoid')(drop2)\n",
    "#output = Dense(1, activation='sigmoid')(flat)\n",
    "model = Model(inputs=visible, outputs=output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are planning to run less complex model run below lines, i will suggess to use a trasfer learning technique if you are planning to use below model for better results\n",
    "\n",
    "model = keras.Sequential([\n",
    "    keras.layers.Flatten(input_shape=(786, 786, 3)),\n",
    "    keras.layers.Dense(128, activation=tf.nn.relu),\n",
    "    keras.layers.Dense(10, activation=tf.nn.softmax)\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are variety of optimizers available >> https://keras.io/optimizers/\n",
    "More about loss functions >> https://keras.io/losses/\n",
    "Metrics >> https://keras.io/metrics/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import optimizers\n",
    "opt = optimizers.adam(lr=0.001, decay=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer= opt, \n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets convert the array into a numpy array, this might take some time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how the layers are stack on top of each other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_4 (InputLayer)         (None, 128, 128, 3)       0         \n",
      "_________________________________________________________________\n",
      "conv2d_16 (Conv2D)           (None, 117, 117, 16)      6928      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_7 (MaxPooling2 (None, 58, 58, 16)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_17 (Conv2D)           (None, 51, 51, 64)        65600     \n",
      "_________________________________________________________________\n",
      "conv2d_18 (Conv2D)           (None, 48, 48, 64)        65600     \n",
      "_________________________________________________________________\n",
      "conv2d_19 (Conv2D)           (None, 45, 45, 128)       131200    \n",
      "_________________________________________________________________\n",
      "conv2d_20 (Conv2D)           (None, 42, 42, 256)       524544    \n",
      "_________________________________________________________________\n",
      "max_pooling2d_8 (MaxPooling2 (None, 21, 21, 256)       0         \n",
      "_________________________________________________________________\n",
      "flatten_4 (Flatten)          (None, 112896)            0         \n",
      "_________________________________________________________________\n",
      "dense_10 (Dense)             (None, 128)               14450816  \n",
      "_________________________________________________________________\n",
      "dropout_7 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_11 (Dense)             (None, 64)                8256      \n",
      "_________________________________________________________________\n",
      "dropout_8 (Dropout)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_12 (Dense)             (None, 5)                 325       \n",
      "=================================================================\n",
      "Total params: 15,253,269\n",
      "Trainable params: 15,253,269\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This command will actually train the model.\n",
    "Even with less number of images, you might come accross 'Insufficient memory error' or 'Kernel restart error'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "15166/15166 [==============================] - 61s 4ms/step - loss: 4.2956 - acc: 0.7084\n",
      "Epoch 2/5\n",
      "15166/15166 [==============================] - 57s 4ms/step - loss: 4.7102 - acc: 0.6969\n",
      "Epoch 3/5\n",
      "15166/15166 [==============================] - 57s 4ms/step - loss: 4.8894 - acc: 0.6868\n",
      "Epoch 4/5\n",
      "15166/15166 [==============================] - 57s 4ms/step - loss: 4.8836 - acc: 0.6877\n",
      "Epoch 5/5\n",
      "15166/15166 [==============================] - 58s 4ms/step - loss: 4.9612 - acc: 0.6825\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/device:GPU:0'):    \n",
    "    model.fit(x_train_raw, y_train_raw, batch_size=128, epochs=5, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_valid_raw = np.array(X_valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_valid_raw = np.array(Y_valid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the model is trained, we need to evaluate the performance of the model with all validation dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "169/169 [==============================] - 0s 2ms/step\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = model.evaluate(x_valid_raw, y_valid_raw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.338465699077358"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.739644971824962"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default GPU Device: /device:GPU:0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "if tf.test.gpu_device_name():\n",
    "     print(\"Default GPU Device: {}\".format(tf.test.gpu_device_name()))\n",
    "else:\n",
    "     print(\"Please install GPU version of TF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}