my_model_notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "my_model",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KNffqbx5BZow",
        "colab_type": "text"
      },
      "source": [
        " \n",
        "#Classification of Remote Sensing Images\n",
        "## Dataset: RSI-CB"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HpwSEyXvBom2",
        "colab_type": "text"
      },
      "source": [
        "## Install dependencies and create directories"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D5N790uPSh-W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install pyunpack\n",
        "!pip install patool\n",
        "!mkdir rsensing\n",
        "!mkdir rsensing/data\n",
        "!mkdir rsensing/checkpoints\n",
        "!mkdir rsensing/data/model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ecjXBFOZBzUv",
        "colab_type": "text"
      },
      "source": [
        "## Import Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SkdCdw9FG3ix",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%matplotlib inline\n",
        "\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import os\n",
        "import numpy as np\n",
        "import random\n",
        "from PIL import Image\n",
        "import PIL\n",
        "from tensorflow.python.framework import ops\n",
        "import math\n",
        "from urllib.request import urlretrieve\n",
        "from os.path import isfile, isdir\n",
        "from tqdm import tqdm\n",
        "from pyunpack import Archive\n",
        "\n",
        "\n",
        "# Use second GPU -- change if you want to use a first one\n",
        "os.environ[\"CUDA_VISIBLE_DEVICES\"] = '0'\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oQvyCpJZHImO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "path = '/content/rsensing/data/'\n",
        "file_size = 128\n",
        "url = 'https://public.sn.files.1drv.com/y4mZZrgruZn4OM__kE-gGKluqBiGRoV51_d_TJAVLak2KMWqnhRKguCK05YiOr6L-6uiM0GNMIAjWHE_fXR2yLbCbLYBmPehbzJ2kSz6MoCPI4foyq3trliEiam-28oMmbw_rwHzSwERusgbjf3Ebi0xUgouXOkgS2xnE0SEG2MN9cBURB4Gm_w7sNC900fyicAVPf4ezgRZhBvW-OGv22WmA/RSI-CB128.rar?access_token=EwD4Aq1DBAAUcSSzoTJJsy%2bXrnQXgAKO5cj4yc8AAWAOH1mGmk7emoypweN3SIxTAfXJRg7MaPUSTJetYRMIkHr4hpc7fdKy7MZbSJJZ1fF9M2ofqFzBByw5bZlU9yjxMvsGbAFqulmeH242Dj0nEpuTbzKCdMPQQoJwfu%2bFBffD5YEYpN04EqvvpmR5eWwotbaQrf7ueuGuu9ZuM%2fQAfYNeBgrubw%2bjrZKkuS23cfhTXNnj4RzfRPUL9QkeJHO%2f3fo5bPTv%2bXlJX%2bNNcWg6DGLItwYkbCVZAugYjpmN8hR0%2faBHah8mK9pwMqgFm4VZFbeS4v1u5iSAYw%2flye0TuTEjd4ChWJTVHVGA6ovjHQ%2berA7CKIN7JMWdJTL8sQMDZgAACHvy4JmzOBZ2yAEBSIBwGKg95M45cfqd3yBa%2fKg1GxGdcl1Wa4jxFcZU21NFiJ28PDLWJzp0Wwn9pgNtemDIWhfkkTwHDI3Umbmu3aH1sndywLS6dSRInZvcue4Ddpz0eWkYqwstq5KggM6AIgZ8hbMKFYf6bwiz6UvupEuq1ND1mvFy1EP4D7p%2b3ctU07t0QyiLdSiqowuk18P5rSik8OPZNziKovdLnDXGELyDH6dQlPK0vtL1nRSwDT9JXKQixlYPbp%2fu1cc8VpUwVivcOoiaG1S4vbIOOxyyA1bKFVKjkXHgE%2bJgt%2bj5i6yqADblEhikWccoh3%2b6ys8%2f7nuWxqPVN8VSTqy7kQnngTg3nFDipEzSLkNXxBA8Q5XGiGfVeXjb9JtqEOqfk941GEKVIkHgqNV34D9q%2bBvuQKuAHnC3gbhaKPO0quN6aSjPHQr76yuYUX5IcYEnzCVA7KPVBgmpXttTJvxQbCh5eC4zw0i%2fE101j71jXPGRuYSacwASk7DKhwXhRT8ivPRH%2baeOxNgj3L%2fuhBGI%2byvEt9DdydUWnzfjZR7NulnNrI3E2gXZxih%2bVki30o9b6dEfyu9CxrCekKutmwRN8ba2aWCs3TVUouYHAg%3d%3d'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sMAulxyVF2Wi",
        "colab_type": "text"
      },
      "source": [
        "## Download and Extract dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bmPOnBk3HZUr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# DOWNLOAD DATASET\n",
        "\n",
        "data_dir = str(path)\n",
        "\n",
        "class DLProgress(tqdm):\n",
        "    last_block = 0\n",
        "\n",
        "    def hook(self, block_num=1, block_size=1, total_size=None):\n",
        "        self.total = total_size\n",
        "        self.update((block_num - self.last_block) * block_size)\n",
        "        self.last_block = block_num\n",
        "\n",
        "\n",
        "with DLProgress(unit='B', unit_scale=True, miniters=1, desc='RSI-CB Data Set') as pbar:\n",
        "    urlretrieve(str(url), data_dir + 'RSI-CB128.rar', pbar.hook)\n",
        "\n",
        "    \n",
        "# EXTRACT DATASET    \n",
        "\n",
        "Archive(str(path) + 'RSI-CB128.rar').extractall(str(path))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7K70NaXPF71P",
        "colab_type": "text"
      },
      "source": [
        "### Define number of train and test images"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cJIFnGULyjNs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_size = 18342\n",
        "test_size = 3690"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nr3_UbcxGD6U",
        "colab_type": "text"
      },
      "source": [
        "## Generate and save Train Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X6FTLkMczMr5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "classes = os.listdir(str(path) + 'RSI-CB' + str(file_size))\n",
        "index = 0\n",
        "counter = 0\n",
        "print('creating')\n",
        "X_train = np.zeros((train_size, int(file_size), int(file_size), 3), dtype = 'uint8')\n",
        "Y_train = np.zeros((train_size, 1), dtype = 'uint8')\n",
        "print('created')\n",
        "print(classes[2])\n",
        "for i in classes:\n",
        "  subclasses = os.listdir(str(path) + 'RSI-CB' + str(file_size) + '/' + str(i))  \n",
        "  index = classes.index(str(i))\n",
        "  print(index, i, counter) \n",
        "  #print(subclasses[1])\n",
        "  for kk in subclasses:\n",
        "    files = os.listdir(str(path) + 'RSI-CB' + str(file_size) + '/' + str(i) + '/' +  str(kk))\n",
        "    count_temp = 0\n",
        "    for k in range(0, int(len(files) * 0.5)):\n",
        "      img = Image.open(str(path) + 'RSI-CB' + str(file_size) + '/' + str(i) + '/' + str(kk) + '/' + str(files[k]))\n",
        "      img.load\n",
        "      img = img.resize((int(file_size), int(file_size)), PIL.Image.ANTIALIAS)\n",
        "      if np.asarray( img, dtype=\"uint8\" ).shape[0] is int(file_size):\n",
        "        X_train[counter,:,:,:] = np.asarray( img, dtype=\"uint8\" )\n",
        "        Y_train[counter][0] = index\n",
        "        counter += 1\n",
        "        count_temp += 1\n",
        "      \n",
        "      \n",
        "print(counter)\n",
        "\n",
        "np.save(str(path) + 'X_train_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(train_size) + '.npy', X_train)\n",
        "np.save(str(path) + 'Y_train_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(train_size) + '.npy', Y_train)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEgki4fxGKsX",
        "colab_type": "text"
      },
      "source": [
        "## Generate and save Test Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CmKKvdqwKw7-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#GENERATE TESTING DATASET\n",
        "\n",
        "classes = os.listdir(str(path) + 'RSI-CB' + str(file_size))\n",
        "index = 0\n",
        "counter = 0\n",
        "print('creating')\n",
        "X_test = np.zeros((test_size, int(file_size), int(file_size), 3), dtype = 'uint8')\n",
        "Y_test = np.zeros((test_size, 1), dtype = 'uint8')\n",
        "print('created')\n",
        "\n",
        "for i in classes:\n",
        "  subclasses = os.listdir(str(path) + 'RSI-CB' + str(file_size) + '/' + str(i))\n",
        "  index = classes.index(str(i))\n",
        "  print(index, i, counter)  \n",
        "\n",
        "  for kk in subclasses:\n",
        "    files = os.listdir(str(path) + 'RSI-CB' + str(file_size) + '/' + str(i) + '/' +  str(kk))\n",
        "    count_temp = 0\n",
        "    for k in range(int(len(files) * 0.9), len(files)):\n",
        "      img = Image.open(str(path) + 'RSI-CB' + str(file_size) + '/' + str(i) + '/' + str(kk) + '/' + str(files[k]))\n",
        "      img.load\n",
        "      img = img.resize((int(file_size), int(file_size)), PIL.Image.ANTIALIAS)\n",
        "      if np.asarray( img, dtype=\"uint8\" ).shape[0] is int(file_size):\n",
        "        X_test[counter,:,:,:] = np.asarray( img, dtype=\"uint8\" )\n",
        "        Y_test[counter][0] = index\n",
        "        counter += 1\n",
        "        count_temp += 1\n",
        "           \n",
        "print(counter)\n",
        "\n",
        "np.save(str(path) + 'X_test_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(test_size) + '.npy', X_test)\n",
        "np.save(str(path) + 'Y_test_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(test_size) + '.npy', Y_test)\n",
        "\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PzoUkAl2-bfC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(X_train.shape, Y_train.shape)\n",
        "print(X_test.shape, Y_test.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ea7SrDGdGrne",
        "colab_type": "text"
      },
      "source": [
        "## Load and Normalize Train and Test Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SZgSCElKIwOl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "trainx = np.load(str(path) + 'X_train_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(train_size) + '.npy')\n",
        "trainy = np.load(str(path) + 'Y_train_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(train_size) + '.npy')\n",
        "\n",
        "testx = np.load(str(path) + 'X_test_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(test_size) + '.npy')\n",
        "testy = np.load(str(path) + 'Y_test_' + str(file_size) + 'X' + str(file_size) + 'X3X' + str(test_size) + '.npy')\n",
        "\n",
        "\n",
        "X_train = trainx/255\n",
        "X_train = X_train.astype('float16')\n",
        "X_train = np.resize(X_train, (train_size, 64, 64, 3))\n",
        "\n",
        "X_test = testx/255\n",
        "X_test = X_test.astype('float16')\n",
        "X_test = np.resize(X_test, (test_size, 64, 64, 3))\n",
        "\n",
        "def convert_to_one_hot(Y, C):\n",
        "    Y = np.eye(C)[Y.reshape(-1)].T\n",
        "    return Y\n",
        "  \n",
        "Y_train = convert_to_one_hot(trainy, 8).T  \n",
        "Y_test = convert_to_one_hot(testy, 8).T\n",
        "\n",
        "print(X_train.shape, Y_train.shape)\n",
        "print(X_test.shape, Y_test.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jfCd6w9pdM_M",
        "colab_type": "text"
      },
      "source": [
        "## Compute cost and minibatches"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OAR1HE_SdxPz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_placeholders(n_H0, n_W0, n_C0, n_y):\n",
        "    \"\"\"\n",
        "    Creates the placeholders for the tensorflow session.\n",
        "    \n",
        "    n_H0 -- height of an input image\n",
        "    n_W0 -- width of an input image\n",
        "    n_C0 -- number of channels of the input\n",
        "    n_y  --  number of classes\n",
        "        \n",
        "    Returns:\n",
        "    X -- placeholder for the data input, of shape [None, n_H0, n_W0, n_C0] and dtype \"float\"\n",
        "    Y -- placeholder for the input labels, of shape [None, n_y] and dtype \"float\"\n",
        "    \"\"\"\n",
        "\n",
        "    X = tf.placeholder(tf.float32, [None, n_H0, n_W0, n_C0], name = 'X')\n",
        "    Y = tf.placeholder(tf.float32, [None, n_y], name = 'Y')\n",
        "    \n",
        "    return X, Y\n",
        "   \n",
        "  \n",
        "def compute_cost(Z3, Y):\n",
        "    \"\"\"\n",
        "    Computes the cost\n",
        "    \n",
        "    Z3   - output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)\n",
        "    Y    - \"true\" labels vector placeholder, same shape as Z3\n",
        "    cost - Tensor of the cost function\n",
        "    \"\"\"\n",
        "    \n",
        "    cost = tf.nn.softmax_cross_entropy_with_logits(logits = Z3, labels = Y)\n",
        "    cost = tf.reduce_mean(cost)\n",
        "    \n",
        "    return cost\n",
        "  \n",
        "  \n",
        "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 10):\n",
        "    \"\"\"\n",
        "    Creates a list of random minibatches from (X, Y)\n",
        "\n",
        "    X               - input data, of shape (input size, number of examples)\n",
        "    Y               - true \"label\" vector (containing index of image class\n",
        "    mini_batch_size - size of the mini-batches    \n",
        "    mini_batches    - list of synchronous (mini_batch_X, mini_batch_Y)\n",
        "    \"\"\"\n",
        "    \n",
        "    m = X.shape[0]                  # number of training examples\n",
        "    mini_batches = []\n",
        "    np.random.seed(seed)\n",
        "    \n",
        "    # Step 1: Shuffle (X, Y)\n",
        "    permutation = list(np.random.permutation(m))\n",
        "    shuffled_X = X[permutation,:,:,:]\n",
        "    shuffled_Y = Y[permutation,:]\n",
        "\n",
        "    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n",
        "    num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning\n",
        "    for k in range(0, num_complete_minibatches):\n",
        "        mini_batch_X = shuffled_X[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:,:,:]\n",
        "        mini_batch_Y = shuffled_Y[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:]\n",
        "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
        "        mini_batches.append(mini_batch)\n",
        "    \n",
        "    # Handling the end case (last mini-batch < mini_batch_size)\n",
        "    if m % mini_batch_size != 0:\n",
        "        mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m,:,:,:]\n",
        "        mini_batch_Y = shuffled_Y[num_complete_minibatches * mini_batch_size : m,:]\n",
        "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
        "        mini_batches.append(mini_batch)\n",
        "    \n",
        "    return mini_batches\n",
        "  \n",
        "  \n",
        "     \n",
        "      "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YzHUESwfeRn_",
        "colab_type": "text"
      },
      "source": [
        "## Define Training Network"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ag4LN0YrlzWr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def forward_propagation(X):\n",
        "    \n",
        "    # CONV >> ACTIVATION >> POOL >> FLATTEN >> FULLY CONNECTED\n",
        "    \n",
        "    gen1 = tf.layers.conv2d(X, 8, 4, 1, padding = 'SAME')\n",
        "    A1 = tf.nn.relu(gen1)    \n",
        "    P1 = tf.nn.max_pool(A1, ksize = [1,2,2,1], strides = [1,2,2,1], padding = 'SAME')\n",
        "    \n",
        "    gen2 = tf.layers.conv2d(P1, 16, 4, 1, padding = 'SAME')\n",
        "    A2 = tf.nn.relu(gen2)    \n",
        "    P2 = tf.nn.max_pool(A2, ksize = [1,4,4,1], strides = [1,4,4,1], padding = 'SAME')\n",
        "    \n",
        "    gen3 = tf.layers.conv2d(P2, 32, 4, 1, padding = 'SAME')\n",
        "    A3 = tf.nn.tanh(gen3)  \n",
        "    P3 = tf.nn.max_pool(A3, ksize = [1,2,2,1], strides = [1,2,2,1], padding = 'SAME')    \n",
        "    \n",
        "    gen4 = tf.layers.conv2d(P3, 8, 3, 1, padding = 'SAME')\n",
        "    A4 = tf.nn.sigmoid(gen4)  \n",
        "    P4 = tf.nn.max_pool(A4, ksize = [1,2,2,1], strides = [1,2,2,1], padding = 'SAME')    \n",
        "    \n",
        "    # FLATTEN\n",
        "    P_fl = tf.contrib.layers.flatten(P4)\n",
        "    \n",
        "    # FULLY CONNECTED\n",
        "    fc = tf.contrib.layers.fully_connected(P_fl, 8, activation_fn = None)\n",
        "    \n",
        "    return fc"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xn8f9VuqFql0",
        "colab_type": "text"
      },
      "source": [
        "## Training Model\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jo2ymlmxDmqH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0005,\n",
        "          num_epochs = 100, minibatch_size = 64, print_cost = True):\n",
        "    \"\"\"\n",
        "    X_train -  training set, shape  (?, 64, 64, 3)\n",
        "    Y_train -  test set,     shape  (?, n_y = 8)\n",
        "    X_test  -  training set, shape  (?, 64, 64, 3)\n",
        "    Y_test  -  test set,     shape  (?, n_y = 8)\n",
        "    \n",
        "    learning_rate  -  learning rate of the optimization\n",
        "    num_epochs     -  number of epochs of the optimization loop\n",
        "    minibatch_size -  size of a minibatch\n",
        "    print_cost     -  True to print the cost every 100 epochs\n",
        "    \n",
        "    train_accuracy - accuracy on the train set (X_train)\n",
        "    test_accuracy  - testing accuracy on the test set (X_test)\n",
        "    \"\"\"\n",
        "    \n",
        "  \n",
        "    print('X_train shape', X_train.shape)  \n",
        "    print('Y_train shape', Y_train.shape)  \n",
        "    print('X_test shape', X_test.shape)  \n",
        "    print('Y_test shape', Y_test.shape)\n",
        "    print('Learning rate:', learning_rate)\n",
        "    \n",
        "  \n",
        "  \n",
        "    ops.reset_default_graph()        # to be able to rerun the model without overwriting tf variables\n",
        "    tf.set_random_seed(1)                              # to keep results consistent (tensorflow seed)\n",
        "    seed = 3                                                # to keep results consistent (numpy seed)\n",
        "    (m, n_H0, n_W0, n_C0) = X_train.shape             \n",
        "    n_y = Y_train.shape[1]                            \n",
        "    costs = []                                                            # To keep track of the cost\n",
        "    \n",
        "    t1 = 0\n",
        "    t2 = 0\n",
        "    \n",
        "    X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\n",
        "        \n",
        "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
        "     \n",
        "    Z3 = forward_propagation(X)\n",
        "    \n",
        "    # Cost function\n",
        "     \n",
        "    cost = compute_cost(Z3, Y)\n",
        "    \n",
        "    # defining adam optimizer\n",
        "     \n",
        "    optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)\n",
        "    \n",
        "    \n",
        "    # Initialize all the variables globally\n",
        "    init = tf.global_variables_initializer()\n",
        "    \n",
        "    saver = tf.train.Saver()\n",
        "\n",
        "     \n",
        "    # Start the session to compute the tensorflow graph\n",
        "    with tf.Session() as sess:\n",
        "        \n",
        "        # Run the initialization\n",
        "        sess.run(init)\n",
        "        \n",
        "        for epoch in range(num_epochs):\n",
        "            \n",
        "            minibatch_cost = 0.\n",
        "            num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
        "            seed = seed + 1\n",
        "            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
        "\n",
        "            for minibatch in minibatches:\n",
        "\n",
        "                # Select a minibatch\n",
        "                (minibatch_X, minibatch_Y) = minibatch\n",
        "                #  runs the graph on a minibatch.\n",
        "                # Run the session to execute the optimizer and the cost, \n",
        "                # the feedict should contain a minibatch for (X,Y).\n",
        "                 \n",
        "                _ , temp_cost = sess.run([optimizer, cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})\n",
        "                \n",
        "                \n",
        "                minibatch_cost += temp_cost / num_minibatches\n",
        "                \n",
        "\n",
        "            # Print the cost every epoch\n",
        "            if print_cost == True and epoch % 5 == 0:\n",
        "                t2 = time.time()\n",
        "                print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost), 'Time:', round(t2-t1, 4))\n",
        "                t1 = time.time()\n",
        "            if print_cost == True and epoch % 1 == 0:\n",
        "                costs.append(minibatch_cost)\n",
        "                \n",
        "        print('Saving Model...')\n",
        "        saver.save(sess, str(path) + 'model/model.ckpt')\n",
        "        print('Model Saved...')\n",
        "                \n",
        "                \n",
        "        \n",
        "        \n",
        "        # plot the cost\n",
        "        plt.plot(np.squeeze(costs))\n",
        "        plt.ylabel('cost')\n",
        "        plt.xlabel('iterations (per tens)')\n",
        "        plt.title(\"Learning rate =\" + str(learning_rate))\n",
        "        plt.show()\n",
        "\n",
        "        # Calculate the correct predictions\n",
        "        predict_op = tf.argmax(Z3, 1)\n",
        "        correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n",
        "        # Calculate accuracy on the test set\n",
        "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
        "        print('accuracy', accuracy)\n",
        "        train_accuracy = accuracy.eval({X: X_train, Y: Y_train})\n",
        "        test_accuracy = accuracy.eval({X: X_test, Y: Y_test})\n",
        "        print(\"Train Accuracy:\", train_accuracy)\n",
        "        print(\"Test Accuracy:\", test_accuracy)\n",
        "                \n",
        "\n",
        "          \n",
        "        return train_accuracy\n",
        " "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cu8HGnKye7_I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "acc = model(X_train, Y_train, X_test, Y_test, learning_rate=0.003, num_epochs = 100,\n",
        "                       minibatch_size = 64)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "unQHAgkQx0mR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}