python-examples/convnet-with-tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolutional Neural Networks: Application\n",
    "\n",
    "This nootebook will implement a fully functioning ConvNet using TensorFlow \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.0 - TensorFlow model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "from cnn_utils import *\n",
    "\n",
    "%matplotlib inline\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the \"SIGNS\" dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The SIGNS dataset is a collection of 6 signs representing numbers from 0 to 5.\n",
    "\n",
    "<img src=\"images/SIGNS.png\" style=\"width:800px;height:300px;\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 6\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (1080, 64, 64, 3)\n",
      "Y_train shape: (1080, 6)\n",
      "X_test shape: (120, 64, 64, 3)\n",
      "Y_test shape: (120, 6)\n"
     ]
    }
   ],
   "source": [
    "X_train = X_train_orig/255.\n",
    "X_test = X_test_orig/255.\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6).T\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6).T\n",
    "print (\"number of training examples = \" + str(X_train.shape[0]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[0]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))\n",
    "conv_layers = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 - Create placeholders\n",
    "\n",
    "TensorFlow requires to create placeholders for the input data that will be fed into the model when running the session.\n",
    "\n",
    "[Reference](https://www.tensorflow.org/api_docs/python/tf/placeholder)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_placeholders(n_H0, n_W0, n_C0, n_y):\n",
    "    \"\"\"\n",
    "    Creates the placeholders for the tensorflow session.\n",
    "    \n",
    "    Arguments:\n",
    "    n_H0 -- scalar, height of an input image\n",
    "    n_W0 -- scalar, width of an input image\n",
    "    n_C0 -- scalar, number of channels of the input\n",
    "    n_y -- scalar, 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, shape=(None,n_H0, n_W0, n_C0))\n",
    "    Y = tf.placeholder(tf.float32, shape=(None,n_y))\n",
    "\n",
    "    \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = Tensor(\"Placeholder:0\", shape=(?, 64, 64, 3), dtype=float32)\n",
      "Y = Tensor(\"Placeholder_1:0\", shape=(?, 6), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "X, Y = create_placeholders(64, 64, 3, 6)\n",
    "print (\"X = \" + str(X))\n",
    "print (\"Y = \" + str(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 - Initialize parameters\n",
    "\n",
    "Next step is to initialize weights/filters $W1$ and $W2$ using `tf.contrib.layers.xavier_initializer()`. TensorFlow functions take care of the bias. Note that initialization of the weights/filters is for the conv2d functions. TensorFlow initializes the layers for the fully connected part automatically. \n",
    "\n",
    "[Reference](https://www.tensorflow.org/api_docs/python/tf/get_variable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Initializes weight parameters to build a neural network with tensorflow. The shapes are:\n",
    "                        W1 : [4, 4, 3, 8]\n",
    "                        W2 : [2, 2, 8, 16]\n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing W1, W2\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1) \n",
    "        \n",
    "    W1 = tf.get_variable(name='W1', shape=(4,4,3,8), initializer= tf.contrib.layers.xavier_initializer(seed = 0) )\n",
    "    W2 = tf.get_variable(name='W2', shape=(2, 2, 8, 16), initializer= tf.contrib.layers.xavier_initializer(seed = 0) )\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"W2\": W2}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1 = [ 0.00131723  0.1417614  -0.04434952  0.09197326  0.14984085 -0.03514394\n",
      " -0.06847463  0.05245192]\n",
      "W2 = [-0.08566415  0.17750949  0.11974221  0.16773748 -0.0830943  -0.08058\n",
      " -0.00577033 -0.14643836  0.24162132 -0.05857408 -0.19055021  0.1345228\n",
      " -0.22779644 -0.1601823  -0.16117483 -0.10286498]\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess_test:\n",
    "    parameters = initialize_parameters()\n",
    "    init = tf.global_variables_initializer()\n",
    "    sess_test.run(init)\n",
    "    print(\"W1 = \" + str(parameters[\"W1\"].eval()[1,1,1]))\n",
    "    print(\"W2 = \" + str(parameters[\"W2\"].eval()[1,1,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 - Forward propagation\n",
    "\n",
    "In TensorFlow, there are built-in functions that carry out the convolution steps.\n",
    "\n",
    "- **tf.nn.conv2d(X,W1, strides = [1,s,s,1], padding = 'SAME'):** given an input $X$ and a group of filters $W1$, this function convolves $W1$'s filters on X. The third input ([1,f,f,1]) represents the strides for each dimension of the input (m, n_H_prev, n_W_prev, n_C_prev). The full documentation is [here](https://www.tensorflow.org/api_docs/python/tf/nn/conv2d)\n",
    "\n",
    "- **tf.nn.max_pool(A, ksize = [1,f,f,1], strides = [1,s,s,1], padding = 'SAME'):** given an input A, this function uses a window of size (f, f) and strides of size (s, s) to carry out max pooling over each window. The full documentation is [here](https://www.tensorflow.org/api_docs/python/tf/nn/max_pool)\n",
    "\n",
    "- **tf.nn.relu(Z1):** computes the elementwise ReLU of Z1 (which can be any shape). The full documentation is [here.](https://www.tensorflow.org/api_docs/python/tf/nn/relu)\n",
    "\n",
    "- **tf.contrib.layers.flatten(P)**: given an input P, this function flattens each example into a 1D vector it while maintaining the batch-size. It returns a flattened tensor with shape [batch_size, k]. The full documentation is [here.](https://www.tensorflow.org/api_docs/python/tf/contrib/layers/flatten)\n",
    "\n",
    "- **tf.contrib.layers.fully_connected(F, num_outputs):** given a the flattened input F, it returns the output computed using a fully connected layer. The full documentation is [here.](https://www.tensorflow.org/api_docs/python/tf/contrib/layers/fully_connected)\n",
    "\n",
    "In the last function above (`tf.contrib.layers.fully_connected`), the fully connected layer automatically initializes weights in the graph and keeps on training them hence, no need to initialize those weights when initializing the parameters. \n",
    "\n",
    "\n",
    "`forward_propagation` function below builds the following model: `CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED`.  \n",
    "\n",
    "In detail, the following parameters are used for all the steps:\n",
    "     - Conv2D: stride 1, padding is \"SAME\"\n",
    "     - ReLU\n",
    "     - Max pool: Use an 8 by 8 filter size and an 8 by 8 stride, padding is \"SAME\"\n",
    "     - Conv2D: stride 1, padding is \"SAME\"\n",
    "     - ReLU\n",
    "     - Max pool: Use a 4 by 4 filter size and a 4 by 4 stride, padding is \"SAME\"\n",
    "     - Flatten the previous output.\n",
    "     - FULLYCONNECTED (FC) layer: Apply a fully connected layer without an non-linear activation function. Do not call the softmax here. This will result in 6 neurons in the output layer, which then get passed later to a softmax. In TensorFlow, the softmax and cost function are lumped together into a single function, and it can be called in a different function when computing the cost. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"W2\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Z3 -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve the parameters from the dictionary \"parameters\" \n",
    "    W1 = parameters['W1']\n",
    "    W2 = parameters['W2']\n",
    "    \n",
    "    # CONV2D: stride of 1, padding 'SAME'\n",
    "    Z1 = tf.nn.conv2d(X, W1, strides=[1,1,1,1], padding='SAME')\n",
    "    # RELU\n",
    "    A1 = tf.nn.relu(Z1)\n",
    "    # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n",
    "    P1 = tf.nn.max_pool(A1, ksize=[1,8,8,1], strides=[1,8,8,1],padding='SAME')\n",
    "    # CONV2D: filters W2, stride 1, padding 'SAME'\n",
    "    Z2 = tf.nn.conv2d(P1,W2,  strides=[1,1,1,1], padding='SAME')\n",
    "    # RELU\n",
    "    A2 = tf.nn.relu(Z2)\n",
    "    # MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2 = tf.nn.max_pool(A2, ksize=[1,4,4,1], strides=[1,4,4,1], padding='SAME')\n",
    "    # FLATTEN\n",
    "    P2 = tf.contrib.layers.flatten(P2)\n",
    "    # FULLY-CONNECTED without non-linear activation function .\n",
    "    # 6 neurons in output layer. \n",
    "    Z3 = tf.contrib.layers.fully_connected(P2, num_outputs=6, activation_fn=None)\n",
    "\n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z3 = [[ 1.4416982  -0.24909675  5.4504995  -0.26189643 -0.2066989   1.3654672 ]\n",
      " [ 1.4070848  -0.02573231  5.0892797  -0.48669893 -0.40940714  1.2624854 ]]\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    np.random.seed(1)\n",
    "    X, Y = create_placeholders(64, 64, 3, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    init = tf.global_variables_initializer()\n",
    "    sess.run(init)\n",
    "    a = sess.run(Z3, {X: np.random.randn(2,64,64,3), Y: np.random.randn(2,6)})\n",
    "    print(\"Z3 = \" + str(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 - Compute cost\n",
    "\n",
    "- **tf.nn.softmax_cross_entropy_with_logits(logits = Z3, labels = Y):** computes the softmax entropy loss. This function both computes the softmax activation function as well as the resulting loss. The full documentation  [here.](https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits)\n",
    "- **tf.reduce_mean:** computes the mean of elements across dimensions of a tensor. Use this to sum the losses over all the examples to get the overall cost. The full documentation is [here.](https://www.tensorflow.org/api_docs/python/tf/reduce_mean)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(Z3, Y):\n",
    "    \"\"\"\n",
    "    Computes the cost\n",
    "    \n",
    "    Arguments:\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",
    "    \n",
    "    Returns:\n",
    "    cost - Tensor of the cost function\n",
    "    \"\"\"\n",
    "\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = Z3, labels = Y))\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-11-aa57950dc0e9>:16: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "cost = 4.6648703\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    np.random.seed(1)\n",
    "    X, Y = create_placeholders(64, 64, 3, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    init = tf.global_variables_initializer()\n",
    "    sess.run(init)\n",
    "    a = sess.run(cost, {X: np.random.randn(4,64,64,3), Y: np.random.randn(4,6)})\n",
    "    print(\"cost = \" + str(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Model \n",
    "\n",
    "Finally the model can be built.\n",
    "\n",
    "The model below will:\n",
    "\n",
    "- create placeholders\n",
    "- initialize parameters\n",
    "- forward propagate\n",
    "- compute the cost\n",
    "- create an optimizer\n",
    "\n",
    "Last step is to create a session and run a for loop  for num_epochs, get the mini-batches, and then for each mini-batch you will optimize the function. [Documentation for initializing the variables](https://www.tensorflow.org/api_docs/python/tf/global_variables_initializer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.009,\n",
    "          num_epochs = 100, minibatch_size = 64, print_cost = True):\n",
    "    \"\"\"\n",
    "    Implements a three-layer ConvNet in Tensorflow:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set, of shape (None, 64, 64, 3)\n",
    "    Y_train -- test set, of shape (None, n_y = 6)\n",
    "    X_test -- training set, of shape (None, 64, 64, 3)\n",
    "    Y_test -- test set, of shape (None, n_y = 6)\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",
    "    Returns:\n",
    "    train_accuracy -- real number, accuracy on the train set (X_train)\n",
    "    test_accuracy -- real number, testing accuracy on the test set (X_test)\n",
    "    parameters -- parameters learnt by the model. They can then be used to predict.\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",
    "    # Create Placeholders of the correct shape\n",
    "    X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\n",
    "\n",
    "    # Initialize parameters\n",
    "    parameters =  initialize_parameters()\n",
    "    \n",
    "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    \n",
    "    # Cost function: Add cost function to tensorflow graph\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)\n",
    "    \n",
    "    # Initialize all the variables globally\n",
    "    init = tf.global_variables_initializer()\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",
    "        # Do the training loop\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",
    "                # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y).\n",
    "                _ , temp_cost = sess.run([optimizer, cost], feed_dict={X:minibatch_X, Y:minibatch_Y})\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",
    "                print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n",
    "            if print_cost == True and epoch % 1 == 0:\n",
    "                costs.append(minibatch_cost)\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",
    "        \n",
    "        # Calculate accuracy on the test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "        print(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",
    "        return train_accuracy, test_accuracy, parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 1.921332\n",
      "Cost after epoch 5: 1.904156\n",
      "Cost after epoch 10: 1.904309\n",
      "Cost after epoch 15: 1.904477\n",
      "Cost after epoch 20: 1.901876\n",
      "Cost after epoch 25: 1.784094\n",
      "Cost after epoch 30: 1.687816\n",
      "Cost after epoch 35: 1.617915\n",
      "Cost after epoch 40: 1.588563\n",
      "Cost after epoch 45: 1.564675\n",
      "Cost after epoch 50: 1.552992\n",
      "Cost after epoch 55: 1.522002\n",
      "Cost after epoch 60: 1.469448\n",
      "Cost after epoch 65: 1.348049\n",
      "Cost after epoch 70: 1.259512\n",
      "Cost after epoch 75: 1.194649\n",
      "Cost after epoch 80: 1.118853\n",
      "Cost after epoch 85: 1.092969\n",
      "Cost after epoch 90: 1.042783\n",
      "Cost after epoch 95: 1.008652\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Mean_1:0\", shape=(), dtype=float32)\n",
      "Train Accuracy: 0.6759259\n",
      "Test Accuracy: 0.5416667\n"
     ]
    }
   ],
   "source": [
    "_, _, parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}