Improving Neural Networks/week3/Hand_Sign_Detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict\n",
    "\n",
    "%matplotlib inline\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = tf.constant(10)\n",
    "b = tf.constant(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = tf.Variable(a * b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "with tf.Session() as session:\n",
    "    session.run(init)\n",
    "    print(session.run(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_function():\n",
    "    \"\"\"\n",
    "    Implements a linear function: \n",
    "            Initializes W to be a random tensor of shape (4,3)\n",
    "            Initializes X to be a random tensor of shape (3,1)\n",
    "            Initializes b to be a random tensor of shape (4,1)\n",
    "    Returns: \n",
    "    result -- runs the session for Y = WX + b \n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    \n",
    "    ### START CODE HERE ### (4 lines of code)\n",
    "    X = np.random.randn(3, 1)\n",
    "    W = np.random.randn(4, 3)\n",
    "    b = np.random.randn(4, 1)\n",
    "    Y = tf.add(tf.matmul(W, X), b)\n",
    "    ### END CODE HERE ### \n",
    "    \n",
    "    # Create the session using tf.Session() and run it with sess.run(...) on the variable you want to calculate\n",
    "    \n",
    "    sess = tf.Session()\n",
    "    result = sess.run(Y)\n",
    "    \n",
    "    # close the session \n",
    "    sess.close()\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result = \n",
      "[[-2.15657382]\n",
      " [ 2.95891446]\n",
      " [-1.08926781]\n",
      " [-0.84538042]]\n"
     ]
    }
   ],
   "source": [
    "print( \"result = \\n\" + str(linear_function()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Computes the sigmoid of z\n",
    "    \n",
    "    Arguments:\n",
    "    z -- input value, scalar or vector\n",
    "    \n",
    "    Returns: \n",
    "    results -- the sigmoid of z\n",
    "    \"\"\"\n",
    "    \n",
    "    # Create a placeholder for x. Name it 'x'.\n",
    "    x = tf.placeholder(tf.float32, name=\"x\")\n",
    "\n",
    "    # compute sigmoid(x)\n",
    "    sigmoid = tf.sigmoid(x)\n",
    "\n",
    "    # Create a session, and run it. Please use the method 2 explained above. \n",
    "    # You should use a feed_dict to pass z's value to x. \n",
    "    with tf.Session() as sess: \n",
    "        # Run session and call the output \"result\"\n",
    "        result = result = sess.run(sigmoid, feed_dict = {x: z})\n",
    "    \n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid(0) = 0.5\n",
      "sigmoid(12) = 0.9999938\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print (\"sigmoid(12) = \" + str(sigmoid(12)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost(logits, labels):\n",
    "    \"\"\"\n",
    "    Computes the cost using the sigmoid cross entropy\n",
    "    \n",
    "    Arguments:\n",
    "    logits -- vector containing z, output of the last linear unit (before the final sigmoid activation)\n",
    "    labels -- vector of labels y (1 or 0) \n",
    "    \n",
    "    Note: What we've been calling \"z\" and \"y\" in this class are respectively called \"logits\" and \"labels\" \n",
    "    in the TensorFlow documentation. So logits will feed into z, and labels into y. \n",
    "    \n",
    "    Returns:\n",
    "    cost -- runs the session of the cost (formula (2))\n",
    "    \"\"\"\n",
    "    \n",
    "    # Create the placeholders for \"logits\" (z) and \"labels\" (y) (approx. 2 lines)\n",
    "    z = tf.placeholder(tf.float32, name=\"z\")\n",
    "    y = tf.placeholder(tf.float32, name=\"y\")\n",
    "    \n",
    "    # Use the loss function (approx. 1 line)\n",
    "    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z, labels=y)\n",
    "    \n",
    "    # Create a session (approx. 1 line). See method 1 above.\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session (approx. 1 line).\n",
    "    cost = sess.run(cost, feed_dict={z: logits, y: labels})\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/arib/anaconda2/lib/python2.7/site-packages/tensorflow/python/ops/nn_impl.py:180: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "cost = [0.79813886 0.91301525 0.40318605 0.34115386]\n"
     ]
    }
   ],
   "source": [
    "logits = np.array([0.2,0.4,0.7,0.9])\n",
    "\n",
    "cost = cost(logits, np.array([0,0,1,1]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot_matrix(labels, C):\n",
    "    \"\"\"\n",
    "    Creates a matrix where the i-th row corresponds to the ith class number and the jth column\n",
    "                     corresponds to the jth training example. So if example j had a label i. Then entry (i,j) \n",
    "                     will be 1. \n",
    "                     \n",
    "    Arguments:\n",
    "    labels -- vector containing the labels \n",
    "    C -- number of classes, the depth of the one hot dimension\n",
    "    \n",
    "    Returns: \n",
    "    one_hot -- one hot matrix\n",
    "    \"\"\"\n",
    "    \n",
    "    # Create a tf.constant equal to C (depth), name it 'C'. (approx. 1 line)\n",
    "    C = tf.constant(C, name='C')\n",
    "    \n",
    "    # Use tf.one_hot, be careful with the axis (approx. 1 line)\n",
    "    one_hot_matrix = tf.one_hot(indices=labels, depth=C, axis=0)\n",
    "    \n",
    "    # Create the session (approx. 1 line)\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session (approx. 1 line)\n",
    "    one_hot = sess.run(one_hot_matrix)\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    \n",
    "    return one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one_hot = \n",
      "[[0. 0. 0. 1. 0. 0.]\n",
      " [1. 0. 0. 0. 0. 1.]\n",
      " [0. 1. 0. 0. 1. 0.]\n",
      " [0. 0. 1. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "labels = np.array([1,2,3,0,2,1])\n",
    "one_hot = one_hot_matrix(labels, C = 4)\n",
    "print (\"one_hot = \\n\" + str(one_hot))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ones(shape):\n",
    "    \"\"\"\n",
    "    Creates an array of ones of dimension shape\n",
    "    \n",
    "    Arguments:\n",
    "    shape -- shape of the array you want to create\n",
    "        \n",
    "    Returns: \n",
    "    ones -- array containing only ones\n",
    "    \"\"\"\n",
    "    \n",
    "    # Create \"ones\" tensor using tf.ones(...). (approx. 1 line)\n",
    "    ones = tf.ones(shape)\n",
    "    \n",
    "    # Create the session (approx. 1 line)\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session to compute 'ones' (approx. 1 line)\n",
    "    ones = sess.run(ones)\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    return ones\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ones = [1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print (\"ones = \" + str(ones([3])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the dataset\n",
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 0\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (12288, 1080)\n",
      "Y_train shape: (6, 1080)\n",
      "X_test shape: (12288, 120)\n",
      "Y_test shape: (6, 120)\n"
     ]
    }
   ],
   "source": [
    "# Flatten the training and test images\n",
    "X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0], -1).T\n",
    "X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0], -1).T\n",
    "# Normalize image vectors\n",
    "X_train = X_train_flatten / 255.\n",
    "X_test = X_test_flatten / 255.\n",
    "# Convert training and test labels to one hot matrices\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6)\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6)\n",
    "\n",
    "print(\"number of training examples = \" + str(X_train.shape[1]))\n",
    "print(\"number of test examples = \" + str(X_test.shape[1]))\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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_placeholders(n_x, n_y):\n",
    "    \"\"\"\n",
    "    Creates the placeholders for the tensorflow session.\n",
    "    \n",
    "    Arguments:\n",
    "    n_x -- scalar, size of an image vector (num_px * num_px = 64 * 64 * 3 = 12288)\n",
    "    n_y -- scalar, number of classes (from 0 to 5, so -> 6)\n",
    "    \n",
    "    Returns:\n",
    "    X -- placeholder for the data input, of shape [n_x, None] and dtype \"float\"\n",
    "    Y -- placeholder for the input labels, of shape [n_y, None] and dtype \"float\"\n",
    "    \n",
    "    Tips:\n",
    "    - You will use None because it let's us be flexible on the number of examples you will for the placeholders.\n",
    "      In fact, the number of examples during test/train is different.\n",
    "    \"\"\"\n",
    "\n",
    "    X = tf.placeholder(tf.float32, [n_x, None], name=\"X\")\n",
    "    Y = tf.placeholder(tf.float32, [n_y, None], name=\"Y\")\n",
    "    \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = Tensor(\"X_2:0\", shape=(12288, ?), dtype=float32)\n",
      "Y = Tensor(\"Y_1:0\", shape=(6, ?), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "X, Y = create_placeholders(12288, 6)\n",
    "print (\"X = \" + str(X))\n",
    "print (\"Y = \" + str(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Initializes parameters to build a neural network with tensorflow. The shapes are:\n",
    "                        W1 : [25, 12288]\n",
    "                        b1 : [25, 1]\n",
    "                        W2 : [12, 25]\n",
    "                        b2 : [12, 1]\n",
    "                        W3 : [6, 12]\n",
    "                        b3 : [6, 1]\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing W1, b1, W2, b2, W3, b3\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1)                   # so that your \"random\" numbers match ours\n",
    "        \n",
    "    W1 = tf.get_variable(\"W1\", [25, 12288], initializer = tf.contrib.layers.xavier_initializer(seed=1))\n",
    "    b1 = tf.get_variable(\"b1\", [25, 1], initializer = tf.zeros_initializer())\n",
    "    W2 = tf.get_variable(\"W2\", [12, 25], initializer = tf.contrib.layers.xavier_initializer(seed=1))\n",
    "    b2 = tf.get_variable(\"b2\", [12, 1], initializer = tf.zeros_initializer())\n",
    "    W3 = tf.get_variable(\"W3\", [6, 12], initializer = tf.contrib.layers.xavier_initializer(seed=1))\n",
    "    b3 = tf.get_variable(\"b3\", [6, 1], initializer = tf.zeros_initializer())\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:\n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W1 = <tf.Variable 'W1:0' shape=(25, 12288) dtype=float32_ref>\n",
      "b1 = <tf.Variable 'b1:0' shape=(25, 1) dtype=float32_ref>\n",
      "W2 = <tf.Variable 'W2:0' shape=(12, 25) dtype=float32_ref>\n",
      "b2 = <tf.Variable 'b2:0' shape=(12, 1) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    parameters = initialize_parameters()\n",
    "    print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "    print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "    print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "    print(\"b2 = \" + str(parameters[\"b2\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\"\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",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "    \n",
    "    Z1 = tf.add(tf.matmul(W1, X), b1)                      # Z1 = np.dot(W1, X) + b1\n",
    "    A1 = tf.nn.relu(Z1)                                    # A1 = relu(Z1)\n",
    "    Z2 = tf.add(tf.matmul(W2, A1), b2)                     # Z2 = np.dot(W2, a1) + b2\n",
    "    A2 = tf.nn.relu(Z2)                                    # A2 = relu(Z2)\n",
    "    Z3 = tf.add(tf.matmul(W3, A2), b3)                     # Z3 = np.dot(W3,Z2) + b3\n",
    "    \n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z3 = Tensor(\"Add_2:0\", shape=(6, ?), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    print(\"Z3 = \" + str(Z3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(Z3, Y, parameters=None, regularization=False, lambd=0):\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",
    "    # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)\n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    \n",
    "    # Add Regularization to the cost\n",
    "    regularizer = tf.Variable(initial_value=0, dtype=tf.float32)\n",
    "    for _, weight in parameters.items():\n",
    "        regularizer = regularizer + tf.nn.l2_loss(weight)\n",
    "        \n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels) \n",
    "                          + lambd * regularizer)\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-24-1cc7a60e936c>:22: 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 = Tensor(\"Mean:0\", shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    cost = compute_cost(Z3, Y, parameters=parameters, regularization=True)\n",
    "    print(\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,\n",
    "          num_epochs = 1500, minibatch_size = 32, print_cost = True, regularization=False, lambd=0):\n",
    "    \"\"\"\n",
    "    Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set, of shape (input size = 12288, number of training examples = 1080)\n",
    "    Y_train -- test set, of shape (output size = 6, number of training examples = 1080)\n",
    "    X_test -- training set, of shape (input size = 12288, number of training examples = 120)\n",
    "    Y_test -- test set, of shape (output size = 6, number of test examples = 120)\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",
    "    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 consistent results\n",
    "    seed = 3                                          # to keep consistent results\n",
    "    (n_x, m) = X_train.shape                          # (n_x: input size, m : number of examples in the train set)\n",
    "    n_y = Y_train.shape[0]                            # n_y : output size\n",
    "    costs = []                                        # To keep track of the cost\n",
    "    \n",
    "    # Create Placeholders of shape (n_x, n_y)\n",
    "    X, Y = create_placeholders(n_x, 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, parameters, regularization=regularization, lambd=lambd)\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "    \n",
    "    # Initialize all the variables\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",
    "            epoch_cost = 0.                       # Defines a cost related to an epoch\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",
    "                \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\n",
    "                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "                \n",
    "                epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "            # Print the cost every epoch\n",
    "            if print_cost == True and epoch % 100 == 0:\n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, epoch_cost))\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                costs.append(epoch_cost)\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",
    "        # lets save the parameters in a variable\n",
    "        parameters = sess.run(parameters)\n",
    "        print(\"Parameters have been trained!\")\n",
    "\n",
    "        # Calculate the correct predictions\n",
    "        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))\n",
    "\n",
    "        # Calculate accuracy on the test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "        print(\"Train Accuracy:\", accuracy.eval({X: X_train, Y: Y_train}))\n",
    "        print(\"Test Accuracy:\", accuracy.eval({X: X_test, Y: Y_test}))\n",
    "        \n",
    "        return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 1.855702\n",
      "Cost after epoch 100: 1.017255\n",
      "Cost after epoch 200: 0.733184\n",
      "Cost after epoch 300: 0.573071\n",
      "Cost after epoch 400: 0.468573\n",
      "Cost after epoch 500: 0.381228\n",
      "Cost after epoch 600: 0.313815\n",
      "Cost after epoch 700: 0.253708\n",
      "Cost after epoch 800: 0.203900\n",
      "Cost after epoch 900: 0.166454\n",
      "Cost after epoch 1000: 0.146636\n",
      "Cost after epoch 1100: 0.107285\n",
      "Cost after epoch 1200: 0.086700\n",
      "Cost after epoch 1300: 0.059346\n",
      "Cost after epoch 1400: 0.052291\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "('Train Accuracy:', 0.9990741)\n",
      "('Test Accuracy:', 0.725)\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 2.206411\n",
      "Cost after epoch 100: 1.311257\n",
      "Cost after epoch 200: 1.126952\n",
      "Cost after epoch 300: 1.000716\n",
      "Cost after epoch 400: 0.906086\n",
      "Cost after epoch 500: 0.817861\n",
      "Cost after epoch 600: 0.733334\n",
      "Cost after epoch 700: 0.634921\n",
      "Cost after epoch 800: 0.570977\n",
      "Cost after epoch 900: 0.512140\n",
      "Cost after epoch 1000: 0.476801\n",
      "Cost after epoch 1100: 0.430575\n",
      "Cost after epoch 1200: 0.412589\n",
      "Cost after epoch 1300: 0.379364\n",
      "Cost after epoch 1400: 0.370711\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "('Train Accuracy:', 0.9916667)\n",
      "('Test Accuracy:', 0.80833334)\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test, regularization=True, lambd=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 2.136499\n",
      "Cost after epoch 100: 1.339143\n",
      "Cost after epoch 200: 0.906908\n",
      "Cost after epoch 300: 0.677482\n",
      "Cost after epoch 400: 0.536907\n",
      "Cost after epoch 500: 0.424003\n",
      "Cost after epoch 600: 0.360289\n",
      "Cost after epoch 700: 0.315681\n",
      "Cost after epoch 800: 0.274613\n",
      "Cost after epoch 900: 0.249623\n",
      "Cost after epoch 1000: 0.238163\n",
      "Cost after epoch 1100: 0.222039\n",
      "Cost after epoch 1200: 0.212240\n",
      "Cost after epoch 1300: 0.209171\n",
      "Cost after epoch 1400: 0.197191\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "('Train Accuracy:', 1.0)\n",
      "('Test Accuracy:', 0.8833333)\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test, regularization=True, lambd=0.008)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/arib/anaconda2/lib/python2.7/site-packages/ipykernel_launcher.py:9: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  if __name__ == '__main__':\n",
      "/home/arib/anaconda2/lib/python2.7/site-packages/ipykernel_launcher.py:11: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.3.0.\n",
      "Use Pillow instead: ``numpy.array(Image.fromarray(arr).resize())``.\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your algorithm predicts: y = 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "my_image = \"two1.jpg\"\n",
    "\n",
    "# We preprocess your image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "image = image/255.\n",
    "my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T\n",
    "my_image_prediction = predict(my_image, parameters)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"Your algorithm predicts: y = \" + str(np.squeeze(my_image_prediction)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}