Tensorflow .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem statement: SIGNS Dataset\n",
    "\n",
    "One afternoon, with some friends we decided to teach our computers to decipher sign language. We spent a few hours taking pictures in front of a white wall and came up with the following dataset. It's now your job to build an algorithm that would facilitate communications from a speech-impaired person to someone who doesn't understand sign language.\n",
    "\n",
    "- **Training set**: 1080 pictures (64 by 64 pixels) of signs representing numbers from 0 to 5 (180 pictures per number).\n",
    "- **Test set**: 120 pictures (64 by 64 pixels) of signs representing numbers from 0 to 5 (20 pictures per number).\n",
    "\n",
    "Note that this is a subset of the SIGNS dataset. The complete dataset contains many more signs.\n"
   ]
  },
  {
   "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 tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "y_hat = tf.constant(36, name='y_hat')            # Define y_hat constant. Set to 36.\n",
    "y = tf.constant(39, name='y')                    # Define y. Set to 39\n",
    "\n",
    "loss = tf.Variable((y - y_hat)**2, name='loss')  # Create a variable for the loss\n",
    "\n",
    "init = tf.global_variables_initializer()         # When init is run later (session.run(init)),\n",
    "                                                 # the loss variable will be initialized and ready to be computed\n",
    "with tf.Session() as session:                    # Create a session and print the output\n",
    "    session.run(init)                            # Initializes the variables\n",
    "    print(session.run(loss))                     # Prints the loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "    train_dataset = h5py.File('C:/Users/ssharan/Desktop/tensorflow/datasets/train_signs.h5', \"r\")\n",
    "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
    "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
    "\n",
    "    test_dataset = h5py.File('C:/Users/ssharan/Desktop/tensorflow/datasets/test_signs.h5', \"r\")\n",
    "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
    "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
    "\n",
    "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
    "    \n",
    "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
    "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
    "    \n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 3\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 = 1075\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_one_hot(Y, C):\n",
    "    Y = np.eye(C)[Y.reshape(-1)].T\n",
    "    return Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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)  # 6 are the number of labels in the dataset ( 0,1,2,3,4,5)\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": "markdown",
   "metadata": {},
   "source": [
    "**Note** that 12288 comes from $64 \\times 64 \\times 3$. Each image is square, 64 by 64 pixels, and 3 is for the RGB colors.\n",
    "\n",
    "\n",
    "**The model** is *LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX*. The SIGMOID output layer has been converted to a SOFTMAX. A SOFTMAX layer generalizes SIGMOID to when there are more than two classes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def create_placeholders(n_x, n_y):\n",
    "    X = tf.placeholder(tf.float32,name=\"X\")\n",
    "    Y = tf.placeholder(tf.float32,name=\"Y\")\n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = Tensor(\"X:0\", dtype=float32)\n",
      "Y = Tensor(\"Y:0\", 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": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters():\n",
    "    \n",
    "    tf.set_random_seed(1)                   # so that your \"random\" numbers match ours\n",
    "        \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",
    "\n",
    "    parameters = {\"W1\": W1,\"b1\": b1,\"W2\": W2,\"b2\": b2,\"W3\": W3,\"b3\": b3}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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": "markdown",
   "metadata": {},
   "source": [
    "#### Forward Propagation in Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX\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",
    "                                                                                  # Numpy Equivalents:\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": 28,
   "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": "markdown",
   "metadata": {},
   "source": [
    "### Compute cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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",
    "    # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)\n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits = logits, labels = labels))\n",
    "    \n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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)\n",
    "    print(\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Backward propagation & parameter updates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n",
    "    \"\"\"\n",
    "    Creates a list of random minibatches from (X, Y)\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input data, of shape (input size, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
    "    mini_batch_size - size of the mini-batches, integer\n",
    "    seed -- this is only for the purpose of grading, so that you're \"random minibatches are the same as ours.\n",
    "    \n",
    "    Returns:\n",
    "    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]                  # 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].reshape((Y.shape[0],m))\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, parameters):\n",
    "    \n",
    "    W1 = tf.convert_to_tensor(parameters[\"W1\"])\n",
    "    b1 = tf.convert_to_tensor(parameters[\"b1\"])\n",
    "    W2 = tf.convert_to_tensor(parameters[\"W2\"])\n",
    "    b2 = tf.convert_to_tensor(parameters[\"b2\"])\n",
    "    W3 = tf.convert_to_tensor(parameters[\"W3\"])\n",
    "    b3 = tf.convert_to_tensor(parameters[\"b3\"])\n",
    "    \n",
    "    params = {\"W1\": W1,\n",
    "              \"b1\": b1,\n",
    "              \"W2\": W2,\n",
    "              \"b2\": b2,\n",
    "              \"W3\": W3,\n",
    "              \"b3\": b3}\n",
    "    \n",
    "    x = tf.placeholder(\"float\", [12288, 1])\n",
    "    \n",
    "    z3 = forward_propagation_for_predict(x, params)\n",
    "    p = tf.argmax(z3)\n",
    "    \n",
    "    sess = tf.Session()\n",
    "    prediction = sess.run(p, feed_dict = {x: X})\n",
    "        \n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation_for_predict(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",
    "                                                           # Numpy Equivalents:\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\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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):\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",
    "    ### START CODE HERE ### (1 line)\n",
    "    X, Y = create_placeholders(n_x, n_y)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Initialize parameters\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    parameters = initialize_parameters()\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    Z3 = forward_propagation(X,parameters)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Cost function: Add cost function to tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    cost = compute_cost(Z3,Y)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "    ### END CODE HERE ###\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 for (X,Y).\n",
    "                ### START CODE HERE ### (1 line)\n",
    "                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "                ### END CODE HERE ###\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": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 1.855702\n",
      "Cost after epoch 100: 1.016458\n",
      "Cost after epoch 200: 0.733102\n",
      "Cost after epoch 300: 0.572938\n",
      "Cost after epoch 400: 0.468799\n",
      "Cost after epoch 500: 0.380979\n",
      "Cost after epoch 600: 0.313819\n",
      "Cost after epoch 700: 0.254258\n",
      "Cost after epoch 800: 0.203795\n",
      "Cost after epoch 900: 0.166410\n",
      "Cost after epoch 1000: 0.141497\n",
      "Cost after epoch 1100: 0.107579\n",
      "Cost after epoch 1200: 0.086229\n",
      "Cost after epoch 1300: 0.059415\n",
      "Cost after epoch 1400: 0.052237\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": [
      "Parameters have been trained!\n",
      "Train Accuracy: 0.9990741\n",
      "Test Accuracy: 0.71666664\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test with random image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:/Users/ssharan/Desktop/tensorflow/peace-sign.jpg\n",
      "12288\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ssharan\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:12: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  if sys.path[0] == '':\n",
      "C:\\Users\\ssharan\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:13: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n",
      "  del sys.path[0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your algorithm predicts: y = 2\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQQAAAD8CAYAAACRvtrKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3VuQZdd52Pf/t9bal3Pp6zRmMBgMLgRAiDeRkiCKEmMlocxEohxR5bISKqmITuSiU5FUSsUVR35KpeIHOw+R4oeoIkeOacdlSbYSiVJYcsmkElEMSYl3EwABggAxGMy1p3v6XPfe6/LlYZ9pYURIGAA9GBKzflUzffY+u89Zffr0d/Zel+8TVSXLsgzA3OoGZFn2rSMHhCzLDuWAkGXZoRwQsiw7lANClmWHckDIsuzQTQkIIvLDIvKEiDwlIr9wM54jy7KjJ0c9D0FELPAk8F7gLPAnwE+q6mNH+kRZlh25m3GG8E7gKVV9WlU74NeA99+E58my7Ii5m/CYp4DnXrB9Fvi+v+gbdnZ29J577rkJTcmyDODMmTPs7u7KSx13MwLCiz3pN12XiMiHgA8BnD59mk9+8pM3oSlZlgG8+93vvqHjbsYlw1ng9Au27wbO/dmDVPVXVPURVX1kZ2fnJjQjy7KX62YEhD8BHhKR+0WkBD4AfOQmPE+WZUfsyC8ZVDWIyM8C/wqwwD9S1UeP+nmyLDt6N6MPAVX9KPDRm/HYWZbdPHmmYpZlh3JAyLLsUA4IWZYdygEhy7JDOSBkWXYoB4Qsyw7lgJBl2aEcELIsO5QDQpZlh3JAyLLsUA4IWZYdygEhy7JDOSBkWXYoB4Qsyw7lgJBl2aEcELIsO5QDQpZlh3JAyLLsUA4IWZYdygEhy7JDOSBkWXYoB4Qsyw7lgJBl2aEcELJvCSYKKSU0daQUSMYSE4iJWLkp5UOyF5Ff6exbgjjh+We+xOZaiTGOtguUbp31E/fR+SYHhdfIS77KIvKPgL8CXFLVt672bQO/DtwHfAP4D1V1X0QE+J+B9wEL4K+r6udvTtOz14uUEpe/+HHqZ59A3JBJ25IKQ3HPKWYIa8fvJ0Z/q5t5W7iRS4Z/DPzwn9n3C8DHVPUh4GOrbYAfAR5a/fsQ8MtH08zs9clgC8fzv/fPkK8/wdDWJGC8NmJsS+ZnznH5C58khHCrG3rbeMmAoKp/COz9md3vBz68uv1h4MdfsP+faO/TwKaInDyqxmavL9YqT33stxg3LVUMkAQ7GBLVoFKQmpbi/Nd59v/7nVvd1NvGK+1UPKGq5wFWX4+v9p8CnnvBcWdX+76JiHxIRD4rIp/d3d19hc3Ivp2FAIPLX8O1M3zXEFJE6xHqHN1igpnuMZ/CwRO5ePhr5ahHGeRF9umLHaiqv6Kqj6jqIzs7O0fcjOzPIyKoxtWWwRiHqMNqIKbXdtBpsvcsREPXtbBqlwueZvcyKXTMm4jXlrg8QPVF30bZEXulXbcXReSkqp5fXRJcWu0/C5x+wXF3A+deTQOzoxWjR8T2Gyly+dITNPM9qmqD7bvfAum1a8vimWdxClIVaBeJIbDcuwy+w4eGREQQ1BSvXaNuc6/0I+EjwAdXtz8I/PYL9v+U9N4FHFy7tMi+NRjTfwYsmwkHF77EKE2RyZzFo3/E7LknXtO2dM88BaUjBhBXEEIghUgMEJuAjId0atDhBv0AVnaz3ciw4z8H/h1gR0TOAv8d8PeA3xCRnwbOAD+xOvyj9EOOT9EPO/5nN6HN2ashFmsNB088RvjG47TtkloFlUT8zEe5MDjO8X//A3gNVPYmjP2LxYjCfB+xS0xS7HCIiYqqoes8RqEcj6HrWIQD3vIDf/Xo25G9qJf8javqT/45d/3QixyrwM+82kZlN49qg5ERk69+gWOqWDdEBuuMS8PBdALzM1z+/Mc5+ch7ScSXfsCX+/wp4I3wjU/+HkPfga1xtiBKQNsAPmLqkqadM/MzZHSc8b0PHnk7sheXpy7fbqIlzXdZjw1ilEISVVWwSMpoMGQwB/vM58DcnE68ZCzGOIqrzyJGMWUBVU1SwVqLKSyqq2nMRlk7+QCxqm9KW7JvlgPCbaawyoVnniQsFmgX8PM5aTEDV0BZspSELGH/6cduzvMLxKsXiJ1iqxpjDEXhKF2BcwZTGiIBSOCV+7/ru/+0EzS76XJAuM14EZb7e4haYowE35CaJSWJbjGnKEqmGC4+9umb8vwmdhw89yRutIGxFlc52naJOgMOirpAXACXCCFQnbyb4uivXLI/Rw4ItxlNBRqEaQygCRB8WEJMpKYlNonKgmkbMEqBQ45wLDKlir2vfR0K7T/5UyL4lhAacJYgEWstyVh86cAVN+vqJXsROSDcZkSUwYk7KTAoFlXFtB2oYkjY4RApaqoUMe2MpAH06EYbOidEv4ehn4iUuhYbI1aUFD2x83jvUSNMTYFNBm/yKcJrJQeE20wsYOu+e1cdd6BFAXVBNz8gdDNEIq6oSREuPv1U/z0vOgH1lZEu4OZX0b0pqekIIRA14b2n6zpi6GhDS6ces7kFSRGX5yC8VnJAuM04n6iKdYy0dNqCs6ir0OBxxQBTDzGApMjuV7/AUgVrjm614ezKs5TFgMJA6RymrJCiJLaRZn9CCJ6uC8wWHQ9+1/eTTMJ1ORfCayW/0rcZxaAC85gY24hxFlMWiOrqND4hAkUq2KSlMh0EgSOYpGQN7D76KeygwIkjCogkUgqU6yO0FK5e2qVtWrqQuOP0w1gDovkM4bWSzxBuM6IerGO6+tBXjRRFBcagkrBWoKoohzUxRnaf+gLJvPo/SIPQSMni8jdwpkAL1y+yapYYDbSzCd57ZLyG2TiG1MK4HqBaou41XGBxm8sB4XYjFkmRTi0hdCT1tMsphsS1lU3OClIYnHOcefRzRzIPICqYFCiNQzRCUtQIIUZCjPgQISZIAppYhkgy/QhHjLlT8bWSA8JtJpkCJbJ55ymiQoxKjB7vW1JKmLompQ67emdsxClij+BtIhaTPNYJxhjUWBQD1pJEUCPEogATUWtI1TohKinls4PXUg4ItxmlxaBs3PcgTdeBCiJC8J4YAmExIzYL/HRCmF/F7y3wbXMEz7xkefkZRARrClT1MMeBWtMvuioczgpWIhv3vhFjTF7l+BrLAeE2c22Sz4kH3kRKCd8tabsGv2hoZw3ogHq0gyvWGA7H1BsbzL7xOCLyqv44kxSceeyzlNaRrBz+sZuywLoSqQpSAp+Ezi948M3vOKKfOHs5ckC43SRFiZTjbUKIzHZ36fan2GpIvblDTA2L5oCkSxBDUQ+4/OgXj+Spm/0LWGvBGJIAklArRO0zOeEsKhYjsL5z4kieM3t5ckC4zRgRoGJgLSYpg+E2MhoRoye2M7pmiQkJFSEVph91SAd938OrGP6zUdksDRiHSD9D0loLURBNpKICV4EEOlWq9e2j+6GzG5YDwm0mqWBECViWbkC0lqp0iAWMYMoKT8LYArEFtqoZDAbQTIiv4nK+m13ABO3PBKyBmAhdpOvC4XLnJgS0LFk2AX+E06WzG5cDwm1GZJVrQJW1kw+iVaBLAVOUaGGRWpCqQo1FUt/hUBU1u898uR8WfBlU+wBgjOHcVz6NrWqqwRDnHM6VhGULwaM4kpjViseaWAwpQh5qvBVyQLiN3fUdbyJFsGV/TR9RnHP9sCCANRhjSCiXn/4K1r68ZKd9hud+6HB29TKifQpuESEJFKMBDEq865OjOBXaZYPa8jD3Y/baygHhNrZxz72Ij6TgMcZgEUQVVxSYYrXOwBqcM2zZDmL3sp9DRPDeM3YBUwz7ZVJdQLtAjHH1nP1MxpQSzggn73kDegSzI7OXLweE21m1hReIyYIkfIrgCsT0n+rG9Z1/mhKqBQfnnnpZDy8KURznn/g8Ri1oS2o64tLj5y1psqA5f4U0PyA0S5IPNF3H2qkHSXoUcx+ylysHhNtYMRjT+hbvPb7tsNYeThZyzh3OPRAsw9px4dFPvqzHj8ljNLH35GdxmqALVPUQigHjrW3caIPhzgmMGxE6Twr9bMnh+laekHSL5IBwG4tJiOhhJ2OM8boKSSl4SIKowXeRsj14WY9flCUpRobhANoOq4munfd9C61Hm0VfrclZonVgHTEmtrZ3MJqnLN8KOSDcxpwFxKDGA4q1fScgxmFFcQhFShgCSRxVNejTrWFuaI1BipGrz3+dan0bV5UYwMw8lYB1keHmGLdew6ggJU+7mNLN93H1sJ+TkL3mckC4jYWYmEfBGFadhw5jwInBBu07/kJDii1xMSE1HQdnniaZfi7DS0kRzj35eaK1SFli19aoT52g3tqACCIF2gLTKe3ly5j5kvki0hlHiv7mvwDZN3nJgCAip0XkD0TkcRF5VER+frV/W0R+X0S+tvq6tdovIvIPROQpEfmyiHz3zf4hslfGpg4ZbtGGos9vGFrC0uNnM9pGseNjuPEmZTXClRUxdVz+yh9jkifqSw9BBlsSrp6jDHMkJsQomjqSidT3nqZ+w2kGd5+k3Npm666TuPE6g2PbDLBHmscxu3E3coYQgL+lqm8C3gX8jIi8GfgF4GOq+hDwsdU2wI8AD63+fQj45SNvdXYkjDFs3/0AzWJO8B5UcdrnJ7DjAaZIJFqCaZDQ4KIwTFNUhcK99FvHCHSzq8QuogTUt2i7pJ1exs8vEq6eJczOE+MUU1qoDG60hRLzsudb5CV/q6p6XlU/v7o9BR4HTgHvBz68OuzDwI+vbr8f+Cfa+zSwuaoQnX2LSdHz0Dt+AKeR2HR08yVt01HXNS4uCPtXaM/t0u7OKIsauzbGVSO6/Yv05/p/MUlKxSo1k1fUB4Jv0ejxyxntbEKYTVCf8LEjxMipN74VEaEocsXnW+Fl9SGIyH3AdwGfAU5cq+y8+np8ddgp4LkXfNvZ1b4/+1gfEpHPishnd3d3X37Ls1fNiaPa2mTpl4gCwZPaJe1sisGyfuwUmw++keHWGqp9UtRkHGe+/Clu5APc2ARuhMf1oxgJNAkpKBohRcV7petWk57Us/3A2+hSpA25D+FWuOGAICJj4DeB/0pVJ3/RoS+y75t6oFT1V1T1EVV9ZGdn50abkR0htWDNEB+FLil2sEa5voEbDAkK8+kufrJLms9wJCQGXJzjL30DlZf+BO+mV0ESBsWYfhp0SJ6kio+hTwOfhKQQoqVrWzY2t/sajzfQaZkdvRsKCCJS0AeDf6aq/+dq98VrlwKrr5dW+88Cp1/w7XcD546mudlRCqIgJdY4ikGFEjChg9iQ0oKumRK7GUiiDUvUCoV1rJvAjZRKmF65jBWwzhBj7JOoXltclYTOx1UWR0NMhq7rMLbPpuRsnph0K9zIKIMAvwo8rqr/0wvu+gjwwdXtDwK//YL9P7UabXgXcHDt0iL71mKSQ8XTrR2j6xq64PGa8MsFLDuMQmgDwSdELClGkIJYj9k/+/WXfPzdbzyGGEghkiRgCoMSUSKRfhJUFMU7JZqAbtx5ONz4MhdWZkfkRs4Q3g38p8B7ROSLq3/vA/4e8F4R+Rrw3tU2wEeBp4GngH8I/JdH3+zsKAQFZwJvevePslgsiO2CGDpSUZCMEELoP62dQ66tfBQoioKDx/7wJR9/uXcRwWAMh6seExBVkWvbVrAIqWu5763vvPk/dPYXesnBXlX9I168XwDgh17keAV+5lW2K3sNFJIIUTh2/5t5vl0SBwN02K9hoLD9x7T2a5Y1JrCAiZjgmRzMaGNiYAKCIUr/VlJbImHZZ1QOLZUmJIKpLUKfWPVaMNCyRJOSfGKJsP1gnrJyq+WZihllWbIM/RnBtVqL19Y1XMtmlFIiRo/BYgqHK2AgijV9cpNrNHhkVU9Bkwf65dMaQVVWjxkxzvVVo6oCLSyxi5R1nq58q+WAkKGqNFLiU+w/2dUQuwR67e1hMK4fVYhhBiLUdcne2SdJGuFFCrlYjRTRY2PEJI8hoPh+1MEIydg+87LtE7D05xmvviBM9urkgJABUNx5L10r+K4hhNDnQpBr2Y1SvyrRgJESTREw7J1/loS9boWkmIhqpEuRAkP0gThbossO7VaTlJxDXOrXUGBJKbFz35tBXn4Cluxo5YCQAfDAI3+JEDpi15dZCykRVVEMYvsciCmCkDAKRWGZX3gasVV/VrGiqkRNtNM9rLUM1taRwRrdbEHzjTPo+V3CfEb06fB47z1vfOd7EPLsxFstB4QMgLvuexiM0HUdXecPcyRAv+ZBYx8IiOkwccrYdHR/ZnjQmv6/q5cvkpZzjI9YsdRr24xO34sdDkmXr6B7V4lth/pA6jyMj+f1C98C8pKyDABTjmiahtIYQmwpUoW1/em8RiisEH1ErGBRuhAYVwNGOqeTAdeuGjSUFAb2nnmStUHd121sZxRFgRiDDodU4zWMgab1aGHxXUSixxGJ+S15S+UzhAwAawq68Z2YsiD5QOoCofOQVgVVUp8wJS2XpEWL6zxpNufMpz6C0/Yww7JxSnCCmVzFRKHAMHA1FkF9h4bYJ0pwFcXaOtV4i/VTD2BR/BFUmc5enRwQMgBU4N53/3u0ywZjHCl4tAsveIMYYoKNjS1KYxGFarjBUFuufOpfYGbnSWpxKWF8y7B2bN1zD/X2NuVwhJGKQirMQQvTZf+QrsKubbB5/9tQ6TMvv2jbNK9reK3k87MMgJQSD7zlO/ncH/4LokJh7KoqdERCwmFJCYIpqTYGVE5IUYhiKKsR3VOfZzH/FMv1uzBlwc7GGmVZUqxtIlKQmgWLi89jFZazKXF/RhgEBut3oHX9F7YtJ1x97eSAkPU0osWY1neYsp80lBR8GxhUFdXOCWxVUmgkhAaWCwQobE1IEauKrQyyvEhcKG5zm7qsiGIQY7CFYzxcZ37xHFW8gPczqmpAYQqSefHRhWtnBjkgvHZyQMiA/gzBiacbbOHbjoFRjKkpR2OGG8dwa2u4qiTO9pEU++GEpITFAtpEqgqsWEJI1MMNjBR9MFiNSKgrwASGd95F2tzEX91FraUeVUzme8B9iChBSmbPfonl+SeR6PEqUAzYeeDtFMfuo9KWwGqORL6SOHI5IGQrCcSycfwkMrmMsyWmGlAOS7QSNAVS109QMsYRVcEqzgjJAKFDo+Jiwosiy4JqNCKJ9tOUB0PUWUQ91AU6HtGqYqoR03NnGD30Pdh2we4f/C8Mt+6gLMfg1ihjh18umH7l47RUnPrBn0Rji3mZZeWyG5M7FTPgTwuzrB+/C991LNuGEDt8s0DaOTRzUoiIKTGFw1aOoihWcxQiqpB8gORh9zK1Qncwha5DfUO4uotOLtFNriCho1tMcc7go8WoJ+xf5NLv/hL12haqgonCwJWU9RrD8TZFOcao5/mP/hKlEbiBBC3Zy5cDQgZwOBHJre1gBiPU1XRNi4bUF2BdVXKOMWKtRSIklJTAuQKSIigpRGzhaKZ7aFgg2ldxFhFCs0S7Jc3ygBQ7hIQ4iyynHHziN5CtE7hqDTUDwmJBms2Ju7vEvX2MFAwGI6jGfOFf/XO6GG7xK/b6lANCdp1iOCaEQBcTxaBCnMUWDo2B5JeUhaXrOpIK0QeMgRgDzghWlMKWkBQl4Uj98GVKGOMQa1Fr6HOneZIKZrFHETxBElW5RsCQNFCWZb+Gwhps7ShdRepadNlQTZ6lyh0IN0UOCNl11jeOEdop+DnqI1EjhIDvGrQLdN6jKjjnsNYRVTAkvO/rMsZ2RvKB0XjcJ1tpGxRHkn7UwKgBDWj0EBNf++JnCMuW4XATqQfAtWQqDaIBbJ9abX7lOcLuZZwkNDkufuUTt/iVen3KASG7Tr2xSVBL8KlPhBoSXdOSuo7YzRHv+z9YlJAiGhpSO0VIEAMxBYra0rQLjESUDk0dGjxWBNEO71tCgtjOGFjTJ1VdG1FUI3AFzjm0S3TTKeHqLmG6i29afAw08wXTyQFPf/WxW/1SvS7lUYbsOqYaErB9XQSvSH0tK3LCxEjqOkxV4GLCqhJUiUlJ3RwTEkYsTYxYUUxZkboFupzAYEjsOlQUUiQ0C4KHsq4wm8coRxt9arWY8F2kKBzNwqNNi/ehv2TRyPRgQvKBZZvLxd8MOSBk1xFrQCONF9KyxaWEHVQUzhGMwZmAiY62XWKIaIoYDFEDqpEYIkKBDBzGOUQLwmIPg6FPrmhI4mibq2CUeuc49XiNcrBG0zRYp1h1BG8YDIQWw2DsmBzssZgd0DUts3ZGffLYrX6pXpdyQMiul5RZdNxRD/sU6mWFcw5ED8u9SVI0eWIKIBH1EaORlEDKguRbbPQEaymKkna6i6WAcoRxFlSZTaZsnT6NHY0RV5Jii989T7OcMiASq4owOkZx1/0oDjlfMYgdk6amXXT84Hvfd6tfqdel3IeQXcfYhJYVy26OGwwwdU3CYIzDKHRdR9s0hOWC4Fu8931a9RjBWYK1UAhd8v2cBLFEEdrlVbp2gu8avEK1sUM5HqNGmV25RHPuHNYYhtWY1Clu/QTV2jplBGstd73rh5HtbZYHU7wbkzaOv/QPk71sOSBk1zEhMKwrQujnJkhRYkdDdDAkOkdAMap43xLbJcl3hLYDjWCkT6wqRT/CkBIhdBTlEN82qG/BKF23YG3rJIrBtg1lhMFoja6ZQVlSveEtlBs7WBwYi4bI5MyjrN33Rj776BP82N/6Hyg19yHcDDkgZNcREarROlKUxATJWFoxeBWic7iyoIuBpEK3mBPbBr9coKoEv8QmT+r65c1d7LM4q3XYqqJr54TYzzIshyMkKWkSWStH+EuXGa7tUGzeiXVjbHJg6n6uQ4okPyf4lp/4G/8FiyvncMXgFr9Sr085IGTXEQrEQlIh+Jbp/h7jakRI/WSldtknYR1un6BLyvzSHkgk+YDEACESQ0vXtYg1BAVPot46TldtgbNYqdCgsJgzco4r3/ga6fidpHKTpBacxStgHdEnutkMP5/QzKZYPJMv/z5f/b0Pk6JBSDhX3uqX7XXjRkq51SLyxyLyJRF5VET++9X++0XkMyLyNRH5dREpV/ur1fZTq/vvu7k/QnaUDIn9y5dI0RNiRERpwxLjCqwpUFPQdZ7FdEJVb2I31miuHBCXC/yiWaVci5hV1caoCcEwm3YMyxHqY78GIinBQyoso/sfxOOwVY3YkqQGxBDapu+zWDZMrky5+o2nWXcFg/FJjg0qzv7ePyBGj66mR2ev3o2cIbTAe1T17cA7gB9e1Wz8+8AvqupDwD7w06vjfxrYV9UHgV9cHZd9m0gYjCv7S4J2yXTvMpMLz1MXUI6HVFvb1Bsb+BRxm+uY0Tru+HG0KGmbJbHzfcGXtiF0LWHZMr06RVT6dGymQooSNYIb1bTdDB2uUw43aKygRvqJS8s53bIhhY7ldMrs/LM895UvYKSGdk5qAzJY49Hf+V/7Ds3sSLxkQNDebLVZrP4p8B7gX672fxj48dXt96+2Wd3/Q5IzXHz7MIK1lqqqGI3X2dg5gSsMGgODwYDhWs345Ek2T53AlSXdckZZDZGiZrx1guATJAUjtPMFbfAM17eQwvRDjs721Z1EKK3Dre30ZVqqAmcLuralm89plw2L+T5XL1zk7JP/hvNf/wpvfsv34LsZ4iwpNRjvqVLL9NJz/bRo+gIw2St3o+XgrYh8kb7k++8DXweuquq1JWdngVOr26eA5wBW9x8AeRbJt4mUEmExoVlOEaMY058xLC5dYnb+DC6ZPmGqKraouPfhd+CbBu06VKA8tgUJmkVLNAXDtQ1iUWLKGjXSz2MQSzQFWo+I3mOXLQfPP0M7nxK7KaFrmU32mFzc5czn/jWxm2KT4cr555hevkTbNoRmSdfO8W3D53//N/tycX2p6Vv9En5bu6GAoKpRVd8B3A28E3jTix22+vpiZwPftDRNRD4kIp8Vkc/u7u7eaHuz10CznFIIWKOrRUz9p+7iwvNcPXeGxe5lhqZCZ7ss51c5+dbvReuKrlvg7IBi5zhSjRAxaIDR+gblYI1qtE4IAVtUdAmcGNJsn91nH2X27GP42R7tsuNgf5/dZ5/h/Ff/mM03vBUxhk9/7BNMJxOi2H50g0hoF0ymC+J8wv65ZyDFnG7tVXpZowyqehX4f4B3AZsicm2m493AudXts8BpgNX9G8DeizzWr6jqI6r6yM7OzitrfXbkApaqqCmdYFRwVjDGgXOUwzXm588TLjzL/MJ5imoTCTA/f5btE6cIITCf7rO3P6P1fTBJg4rgKtQWzOdzinpMVKU0wmxyBTUW4z3iF5z/3B+yPPc00+efZDQsOf7wW/n6l/+E3/rwr3Pvw29mtHMnmL6j0ielTRCDp+s6nvzin6ACmlO5vyo3Mspwh4hsrm4PgL8MPA78AfDXVod9EPjt1e2PrLZZ3f9xzXm0v22oKiPj+zODokAKR1lVjDY2oR5Qb2yxPDhg/8xTNBfPkRYLBrYgBlg7fpp5m8AUGCB6T1mWVKbEan9GMJ3OWMwbYtsSmiXtYk5UiylHDJyluXiG0diiNvHM5z/D2a88xlvf/j286fu+j62dHVQjyTfE5RLftCyWHaHzXDrzDMY4rOZLhlfjRtYynAQ+LCKWPoD8hqr+rog8BvyaiPxd4AvAr66O/1Xgn4rIU/RnBh+4Ce3ObgIRQULDsK6p65JotP9DLvr0auPtHQpTMJOO2HR08wOkXTDvAoPjd3DmwsV+dmFsGFQ1fj5htldiQqINIEapVslWNAVC29E1c7xGwv6ShCGOCvYPdplfuczuc8/wnp/6m4y31ihRLIGmW+JnM3zXMJvOaJcdnSqlKYgpocZh8jDkK/aSAUFVvwx814vsf5q+P+HP7m+AnziS1mWvqZQSV889Q0iJJFBJX8otaMDZEsHQzvaQ8Tb4SyyXHYPCMj+4wDem+5TDMRISoUvEzjO5cJ5japjHiK3XqNY3aNsWkyLtcoKP/RwD37TMJjNCYairmq4LzPeWvOdv/DxVPSS1M2j6YcjYeZazOcvlkr1Jhy0qRCE2E4woGs2L92JlNySvdswOGWP4+uc+hSstGCGEQGEDJEG9hRiwwyFmscCMx2xtbXAwmbKvBRiDb5eYZEgpsVgsKDfx3quKAAAgAElEQVQ2WU4nyGBIUXq6doGmQOf7CUexaZhPD2i6iFrBjmq6ZWJ26TLv+9m/zWL3ErGdEMOCZjGlncyYTCYsli3TNmGLgjaGfk2E61PA4wSbL1BfsRwQMgASkZiE2cWn2ayU1icGpRIQnE8EGlLXkkIHIeGM4fLVBa32lxoaIiiIJkAoywqDMJtexU4PELGk5YJiWNMuZviupW0bmi4SQsCsD5ntX6Gk5Pv+gw8wu3yO1M4JzZRutmBxdcLVyQGLecdzZ55mbX2berhOVTguX9lFqxpjDE4SMQeEVywHhAzoe+edNahXogTEJmRo8d6TpE+oGtsl89mEqhz0GZg1oQIpBPB9mfiginWORdsSQ2A8XmN6MCMgCIa9i8+jKviYUBWmywXOWQ6+9BXKO3d4y1/6d+FgBmVEQ8dyNmN5dcre7hVm85arkwWj9eMsZgcc7O+BKSjXN7DbxxFRYjJALiv/SuWAkB0yJEIIeBdhNeMvoWiINPMpftlgXAHOoAgERbTveAyqqAgKtG1LGzyDouDqcoETONg/wNUVoU0sl/1qyKXvsApPP/4ElSt45OG3EGcHFGsVsVG6rmE5nbGYzfABZtOGQmDRNtjhmIIxhS0pNtZxGzt9kEqCyX0Ir1gOCNmKQ5NgrB7mMfCNwdWDfm1B58EYbFHQDyIroETfr3BUEilBp5HgPUVR0cZASonkHIvZHBMiPiS61XqHyd4+Tz3+Ne48ucN3fO+7GAzXEYnMr/YdhNP5jL1Ll/FBOHf2eSyWIEpZlShQGIdaJXVLHn7H96IacRpIeS7CK5YDQgaApEiyji4otfRTk4MmJEZ829GlSOlcX7BlFRA0hb5qU1Ji6vMrSmEpqpK26UjRE2OkbVsifSXprmnxqvzx//sZtEvcdepOvuPt38Pm5mbfR+HAdy3NYsHVq1P2DuZMLh5QDWradkkIgeVkhk+Rwgo6KLGbm9z1hocpBHxe0f+q5ICQAf0IQwJELCqJiFKZvibCcj4nCoyqUX+JIELqWoIPgBBTIoZEjBGNgWpQk1BMUYNNq8IugaZZ0mnkE//3x9m+827WT9Tce+8ptk8coygKom/ooqFrA3t7B1w4f4knvvxVTt1/Pw6lHI6pFDrfoqrUoyFmbYDd2GLzjpN9tqY/p5J0dmNyQMgA0BQorFCOx6T5LkkV7z3tYkEUg61KVMB5RVOHsBpdULDGEKzBOUuX+ssBcYKidL6fOdg1LbOu4/FP/glvePAhTj74MHfefy9mvotxBW3bItpfhhwcHHDx4lW++NlHWbQNy6ee5sTJ49x55wlcKayP1mh9h4iiQehWaxiilBgRUsqdiq9UDggZ0P9xJxW27rqX/ccv0LZ9huUuRlQtTkG9J1pQWyBybWZjomuXiOlHHQrriCJIEqJq30npPa3AE5/4HCffcD8PPfJOjj/4MFJUsFdi276zMiXLlb2LnHn2PGefu8hobYty0DKdHjCZzJjPZ5y86w7WNzeoRwOsKQjG4gdjYoz92okcDF6VHBCyQ6rKd3zXD/KJxz7Tzw0w9CnNTEG37ChGBdYV2CiItYgYOjrKtWE/chCVGBUfAz72nZPetzTLwJf+9Sd48G3fzb3v/j5O3HMfdb1OQpmfDbh6gLWW5y+c4VOf+zxh2WJdTVkZqtGYoq4IvmU8HhGjIkXJwcEVCmvQqmTnjnf0lzw5GLxqOSBk1xnvnEBtiSaLqoVVxeeYImhJVQ1AhdB1fSFWa/FtR1mWfX9D0xBjJKSIj0LsGnYvnuPt//b3cvpt72T79EMUoxEWZXnhOaqqQqxw/tw5/uCPPk1IkcoaRJRqMCKhjMfrqI1UVUldl9SjmjtOvpnlYkYXExvrOd3GUckBIbtOrIYEKeh8QCUddjaWRYUK+KCYoi/2qjGCcyTvSakv3VaIwWpAvIemIVnL8ePHedt730+5vkVaJkqUK1//KrKYUlUVzz/zLB//9KfpkvbVpYOnLGpcYaiqPkHXaG0DV5WM1obYQlBaBpUlRscDb3r7rX7ZXjdyQMiuU6mnHG+SFlNklePQRiX4hmnrIfV5DgprV3UbHOXq2t3HSGmEkAxtSn116LhgGRPD43dTD/uFSJce/zfEyXnElPxfv/U7TDuDqlBYCypYBGMMRWGpRyWFqyicYbyxhnMOMYqNgo8dYkp2Tt57q1+2140cELLrRJRitEYMDaiiGjHG0Mxb1He4pIzWxoSqgpTQzqMpEVDUGQgQY6Truj7PoSt47vEn+c1/+Mv85z/381yZT/g//vH/jiQhpMRiNmFUVLiyxliIXUdV1cTQYewAYwx1XVPVBYUqtjCUZcl8PmfpIwvTYquamPMgHIkcELLrSFI2Nra4sncZJGI04X2DAJqExWIJRqhi11d1os+mLECIgcV0AtZQFwVRDRfPPcvxnRPs7l3hf/yvf5b9psU3ls3jY+pyRBDhyvPnuePknTgVEgljHJUVnFoKjRQ2UtdrmJGjWLSE2K+X6BYtZujwiTxd+YjkaV3ZddQIMfo+07IqIv0pfEoJV1pigq7zNEuP0X5G47JtWM4XxLAkWUULYW37LlxZ8ODDb2P9xDZV7dCqZjTaILmAmAK1UFcDykGJrAJBIQUuBdY21nDOsL612a9idFBJ0XdIFoYuJurhgHL7XkTy6MJRyQEhu45qX7g1+oAkJfqOGFaTgFSx1hJjxHvPsmuYtw1eE25tyNrmSdY3N2mTYWP7DtQNKEYDkgacc4zHY5xzh4lbY9diUOrBGvP5HFJkUJcU1lA5WN9aR1UZr63hCkNRlgTtZ1EaW9D6xHc88v2YnFj1yOSAkF1HpSIsJ0B/Gh68Z9msCrdqok39cGMyQtt5HAq+4crZp7k62Wd0z9t5+KE3sje5wgNvejPN7IDtk6cQUeq6xDlHaR2EgG8jftGA6xcj1c4yGgwZj4f98OKgZLS+RlUXGAQjii0c87bPtGSt8Ia3fg8pdbfyJXtdyQEhu46Q8E2LpEiICQ2RQiOqSoyRcjToOw8Li3MWqUbccc9D3P2dP8DJe+/l6hOfoo2GE3ffx7mvf4UT99zPcjph5/gd1HVN6Sx2NXphjOC7htpZxoMh3nsKC1vbGxRFgRMY1gPKakBhHX65QEJiMBqSkjJNjqKqEc1v46OSOxWz6/TrE/qFSkY9AAmL9y1mtdipKIrVakglLQ/wi332D6acevBh7nrru4jNgvNf+wJbJ9/A7tlnqTaOYcoFk0VDNR7iphNKsQTjsdZQO4stLdo21ANHVRUM18ZYFCFRFAOCs5joaRZLOh+JKHc88DZCgspaouZ+hKOQA0J2HU0BawxJlBQTmgIiEWtXVaFjIOGxkrDVgLX1TQabxzhuhNA1TM4+xf7+HicfeAt7F59HjLK5scm52ZTRaMhyETFYnBi8j1SlY1CXVK6gi57KGuqyYjgcYlFIkaQNThyN70vLh0XE1QPe9SPvR2LAi8Xkk4QjkQNCdh0xjti1fY7EEEGEZAUBXOUoq9GqY7DGmghhTrPfEKOyt7fH8bsf5OQDp7h85muE0LF9591c2tunKAp8LYRuF2fAiFI6GNYF66MRZWGRuu+3qOqCqq4p6wpiIIVEcmGVuEWxTtj1sLGx1S+wyiscj0wOCNk3MdJfDqDa12PEINZgjOFat1NKHWmxZNYtqYdjtu66l+Hxe1nsX2D+/EWSKzl252kOpjPK1JEGI5r2gOnBAVVVUboCU5YMqoq18ZC6shAKbAw4Z3FlgXMl6gR8oAuelBJN09KZir/8/v8IVUEEQuj66lLZq5Zfxex6GomaMAJJY58dyVqqylFVFdVoHVdaBoMRQSpsaOkWU/Yu71KuR4rBgP1pw7333ceV/T2cBT/coLmyx+zqAck3DNc2GBRCSobNYc36eETpAC0Zj8dYV/Q1FjSiKKHz+LbBp0jnI92w5tR3/gApelTJweAI5Vcyu05SIQbt8yRqv4RZBGLs5yGkdg5SMQ8RYoe4AdX6FsN6RDufsGiE+9/4Zi5ffJ4YI2IL5tMDCmdpl0uqwrE5GrA2KEm1sDEeMV4bYi0QW6y1DNfG/dmINUhKiO0XWM3mgXmyvP9v/jekPFX5prjhrphVSfgviMjvrrbvF5HPiMjXROTXRaRc7a9W20+t7r/v5jQ9uxmsGMp6gyT9KXoXE0iB9339hBgTYixlPaLcvJNqbYPJ5Cqz6Zztux5ia/M4e5fOkxIYV9LMJ1BYJpOrlGXFRi2sDUo2NjbY3N5gNK4YrA0YjUaMRgOG46qfmTissZoInUc1sWz6y4a7vvcHqcYbaMx9BjfDy+mb/Xn6Iq/X/H3gF1X1IWAf+OnV/p8G9lX1QeAXV8dl3yZUla3jd+HbP53ss1wuabvEYtmfss+XLYumYTmboAmO7Zxk7dgdTK9eZnJwhUXTEnE0TcAVNUb7xzVGcMmztTlmOCjY3NxkUNUMqoq6HjAYjBgM+mQpJimh6+iahmXbMl8G/GCbf+tH/+Nc8v0muqGAICJ3Az8K/G+rbQHeA/zL1SEfBn58dfv9q21W9/+Q5N/gtw0DnH7jm7HW9nkKY+w78zpPFxKt7/oxf2MxxQAfE7PpAj+bcHBlH1cMcNUIJFGWDhXBNwu2t7cZjmo21tZZ29pg49gm6yd2GKwPKSvHcH1MMVzD1DXFaEDoOppFX5NhMu0I1vJjP/d3IDWHayyyo3ejfQi/BPxtYG21fQy4qnp4IXcWOLW6fQp4DkBVg4gcrI7ffeEDisiHgA8BnD59+pW2Pzti0QTGp+6lso5EpJa6r94UBO8TrVOKkJCuo1RhNllinKWuhwzGazTtAhXbZ1KKgdQ11EVN104Zbm8QDwaMN7coCoMtakge60rEFrjaoKHFlhUpJaz3zPYWaFFQ33MP1XALtZovF26ilzxDEJG/AlxS1c+9cPeLHKo3cN+f7lD9FVV9RFUf2dnZuaHGZjdfUku9uU00JaqKcwaRVQEXIjEI3ke61tO2LVVVodpnSm6aBhWLqtK2ff4E33WICJPJjLXRmPGxYwxGawxG65R1hauHGNOnYjNlxWBtnRg9KoagloAwCZEf++s/Bw5i62/1S/S6diNnCO8GfkxE3gfUwDr9GcOmiLjVWcLdwLnV8WeB08BZEXHABrB35C3PbgqjgTYZzGiTsHeAMYJFiazmJmBplh0mQlVVfREW7ZcuLxYLjPTp22PoGJQVIrCMARFhNptw5/YWrqopS0dSJZR9EhS1BiOWrgugCW0blosZl3avMLznjXgKgl8iVLzI50t2RF7yDEFV/46q3q2q9wEfAD6uqv8J8AfAX1sd9kHgt1e3P7LaZnX/x1U1/wa/TThbM0jw3T/yY7hiAKVD6Au5WlV87Og6j18uWU6nHFy5wmxvn4Mr+7SLOZO9K/jlAr9YEn2gDZ64WLBz7E509wLVeIOiqEAs1hgQAfrcjWKhKAqSwvRgwnSyZP3Ycb7/fX8V1YiVEuPyW+lmejXzEP5b4NdE5O8CXwB+dbX/V4F/KiJP0Z8ZfODVNTF7LUXfIhTc8dDbmIb/v73zi7Etuerzt1bV3ud03zt3ZjyDHQs7GBQnhEgJWBYBETl/SCBYUeABJKJIWIjIUoKiRHmIjCJFymPyEBGkCIJCIiNBAiEhWIgAlsGKogiDCTYeYjsMxuBhGM8fz53pvt1n76paKw9Ve3e3fdu+eG6fvmjqk1rnnN27+1Sf03udqlVr/X7Coda+gTwlxIV5mmqykereDLDdbkl5Js1WhVdViYNiGL6bqviJJ27dusXw0C100Kq1kBNWylnOIIxVd0EFUyEMI/LQo/zJN3/lNb8qrx7+SAHB3d8PvL/d/wTwtXc5Zwd8x30YW+caKEJVIMoBbj5OevGT6CawiYHj3Y4hDK1gCTRUxaR5nimlGrzqdsAsczBu2B2/yHZ7yM2HHuHk9vN86RveSBxusDt+iRC3aHOLlvEGpUyIZYpB2c2cTol4uOXxL/9zmG7o9q37ofeIdS4QwtAahhwXI8uIuoIqh9uD9bx1288cSzNRQ/VSCIqnmbw75eDggM1mIJ3cYTuMxO0BZXfE0e3nKHlXXaXdqhKTKOX0lHznDtOdE8qcOJ1m/vI3vx3prYx7o7/Snc+i/ku4F/LxyyCRUgqgqML2YGTcRIYxIA4eYbxZOxNrQnFiHCMiZ3Jr09ERh7ceIc+Jk8+8QD45weaJdHrCMG4wy5gHDGF354jj4yNchaQbSqx6i5390ANC5wJmRrAZUPAMGHOuF2QtVvI6ewDiUPMHEhQrp7gnhqHOMOJwQJoyJ7df5tZrHqstynNtRhoPH2KaEnPJgJJSwpu5rIugMaBh4LV/+qsIHtDYFwz7ojc3dS6gUhAJ5KOXiF7l1YcQKXNiuDmiaDVqMaOUxLS7Q06GqBOlfr5st1vmueoXPPzwo/WCtkLOwo1H/wRpPkWiEKyw250Qh7qVafPEbp4whETga9/2zYwhMtmE9M+uvdADQucC6kYR5fjFZ1sLshNiQDB8N1Ni1UUQCQiwPbiBHThRq4jKwfYGluvMwkPBy0RORgxbNpsNWiZK3iG6wawQCVAiJ8e3kVLId3bcSRNp+wjbmw9h8ym+DUi55hfmVUIPCJ0L5PZZfOf4iKjCsB0QKwxRCcNIsEzOGbNMtkIIjpoj4wCtpPjw1kPEbW2OunXrFuM4EuKWkoyjF/6g6jaWCdfISXGGMOHF2J3MTK7EG4/xh8+/VAc0DK0Oqdcf7IMeEDoXUFVoCstDUITMwTZS0oyXjFNnDe6OOhweHjLPM2IOVHkzMKykWq+QZxKGlRlzZfPY6xhQdsdHnN45xlTQcSTtdrx855QXd4WT+TMMhzfJZSbKBhGlB4T90ANC5wIu4BimAu7EUcGMOG7IOa+dKlEDOo5ALWEWc/BacYgMpN3LxMGZTmG4eZMpgYfAmAu7nMlk4hiYpond8cTJbuZ4NixlSobDoGwZsKhEN/qKYT/0gNC5C8rm8HD9TA7DgAZBFCxldBxwFQYNmMA4DoCg7kQNjAcj00E1Zblx8yaI4Kc7SppI2wNUA4KTrDAe3sBThjlh0ynJI8MYkRDRYaAUw8S5e89c537TA0LnAiKOF+ehR1+DBCWKgwqiSlQlixBEyG6EENhuN7XeoHk5HN56CBcluDOOYzVfGQaG7YaHHn0NYEzThMahFkHFQImZcXfCl/2pN/HUc3c4PT4CFTLSliet5aFz5fSA0LmAJCHowOHBAe61Z2GItVJRvCCxJh1HFAnCOI7EccCKs9vtYNwSqMcPDm8yTydISQiRnCbGg0M2cWBzcAhW5dOrCYwBSi4nhG2slYsGqjUodPZDDwidz0ExdDggmzG6Y3lmOLiBmRNE8FJQVTbb7eqLEIOz3UR8zkhwZIiUktgeHLIZthRLFAPPNdl4cvsz0GoarCQ8JW4fHXHr1i3unJwgcSCE0IPBnunVHp0LBB0wM1yr0rF7dYCeplPQQLFECIIqlFJqkdIwADDGSNyMzNOOQSPb7SHbwwOGTWQ8OGS73YKCSGAYDohxbCYrtTfi4UceZ9BAGAKGdqm0a6DPEDoXmDFCDARzxCEXZ3PzELGCeNVFyG4MHjnYbBi3Gxxh2IzknNkeHOIC5eSYOA6oBkrJNV8wbBgObiJWSHki6MB444CSjHLrFs888zQhKDdu3GJu/5o9KOyXHhA6F5BF50ACVYHd6m6D1k/szaaKm0iGnDMbIMYIrtVJKWdijMwIWQdCa0wScdwyngshBKIKIUitb3BhnncEFSxnhsMN2frk9TroAaHzOazrds+1d8FAolIsEf0AXAgbqvIR9dZyghBwFUIx4vYAlxoMVBU3IxevQcBqVYGQUAa81KpGMyNuAmY9kXhd9DDcuZRhG3HPmOdqnhIjLhDHAdGI5ZkgUPIEKsSxejICDAKhOG5V+UjDwDjWnEEIoc4qRAhDRENsgq6RIShQreQ6+6cHhM6lSNwQRNBYtxZDjKjWT3JVJYwDhiAaWnKwkOcJ90IcR9DqHI0rjq4OzdoET0IIuAnuAW27FepUY9k+QbgWekDoXEq88Rget6uqkWqstvDVCRYhoEjVRjQjhEgcN4Rhg7hXrYRhS7JUfRrb7EBEiDEiOmKeMcr682EjiO8wq1OE+rz933Rf9Fe6cymPvfZ1WC51W9ELZrkmFIOicUBVSU1i3XL1fvS2oxDDiKcZtUQIAcvVn2HYbNE41NLk5scgIgzjWJcQQBwGgpc6Y2jJzM5+6AGhcykPP/44IgHzXB2hW2Whe53eo/UT36ny6YqQc22Pdg2gI+O4xYcNMUZCELwYilT5tXMXursQ44gvswW15jwtTcKtsw96QOhcyo2HX4vbhEy5dTEanuosAKzWFqCEUDerNAYOt9uafPSCiGOWUStVb00DqrH1JxSQXJceXjUc3QubeMCBCBqF4FV1SaXPEPZFDwidS4mbLcC6xncTCNRP8dyOtU95l5okXCsMg65r/xjj2a16bbEWRWmlyV5nAMv5IoKlhM8nOIpo3x3fFz0gdC5l+/Atihu2PcBFMbz1HrQKQqcVGQ2IQylOUdDNsC4pvFidBeR6C/VnABzFvdSLv1UkSks+ijmnpxPYDtMusrov7tUO/pMi8hER+ZCIfLAde42IvFdEfrvdPtqOi4j8gIg8KSK/KSJvuco/oHN1SAyYGXlOdeqPrDJpIYS6rWhGtgIqNY/gQLF1ixEgDBGGgFEv+kVxyUqqfQzDZp0dVBOYTIjCSy88i6piKd9teJ0r4I8yQ/ir7v7V7v7W9vhdwPvc/c3A+9pjgG8B3ty+3gn84P0abGe/xDgyzzuiVoWklKd1iaAxoBLqxY61C7kGAXcHc0qquYe5ZLycJQiXOgYkVE+GMjeDmLqNGaQWJz39qU8A2nsZ9sgrWTJ8K/Dudv/dwLedO/6jXvkVqkv061/B83SuCZORwAHlJNdKwlAt4hVbcwiWC6oRUKxUxyZ3X7cTUSHtJsTLWlMgBCyX2grNueVHk3EXIBgcv/AMFrbdqGWP3GtAcOAXReTXReSd7djr3P0PAdrta9vxLwU+de5nn2rHOn/MiOOAhlqKnPJE8Tp1X3IA1moFaO7QGiJhM6JxZC01NK91DHGDDCPE2l6d5tO6nSgBwkAuM8XSqq+gquyObiPWtxz3yb2mb7/B3Z8WkdcC7xWRj32ec+82v/ucfaMWWN4J8MY3vvEeh9HZJ0t2XzXiGNouVDNj0LaLIHWpICHgEhjjhillyBmViIsTQ8S9zSYAkcjBjUdq/iFNiBkWa6HSNM9rRWOeT8FLL07aI/c0Q3D3p9vts8BPU12fP70sBdrts+30p4DzV/gbgKfv8jt/2N3f6u5vffzxx7/4v6BzZegQMTsm+QmhJf0Kjg61lkBUQRRD14s2pQRW0DjiKlVejboNuQihuPqacxg2tfEJEUorREKElE8JecJ0qHUMnb3wBQOCiNwQkYeW+8A3AU8A7wHe0U57B/Az7f57gO9quw1fB7y0LC06f7yo24ARlUiUCMUIyLoaqA5OrWpx2VXQ6s0YhtgSjjWwLOe6BMQLBCVEIaVEKemswrF5QtTfWcuiS/dk2Bv3smR4HfDTLdMbgR93958XkV8DflJEvgf4feA72vk/B7wdeBI4Ab77vo+6sxeiBwZqhWLOGVXInhlDM3htDUlGwQRirCrKks+SgCK1TLkuKxTUURSzvGozmoaqw5jrroSqogiHYy1cUpEeEvbEFwwI7v4J4C/c5fgLwDfe5bgD33tfRte5VlSVUgqlCLrR5vxc+xViE0cxM3SoMwjLZfVgjGMEd7IbgqBBEfPqwuSGerlgvmJm63bkcj/njHrraegdj3uhv8qdS1lKk2OMZDM0jusnuJldaDoq7tX7cYi14SkXcCXogBCqJkJTPcnipCigkWxg6IXlAtRmqVIKluZr+dtfrfQi8c6l1HU8FDMGM4YxoGEgUKf0QRX3VozU9paW4iRxUC84XvedluKioIjUQ2XeoTilTIzjyIwhLX+QcyaGkaiGxXEte+5cLX2G0LkUM6tJwpY4nOcZt9rpeF7jrJSCxKEuD9qFXxWUWrDgrNXZ3Wtp85QIUoVWvBhpmi80TJkZ5pnjo5drU1VnL/SA0LmUEALbG4erLoGqstudrBfs8kkOYNOElrJO/aVd7Mt5Cz7XMmaXGnDmeSbGM7GUZYmyPF+Zdr0GYY/0gNC5FPfae+BWxdRzKWy3h4RxaDOAGgxEBKdU4xat/QhL74KI4CljqUqwF6XOOoqv3095RlpDY1Bh2tUgYCoc7V5mI73bcV/0gNC5FHdnnudaeqzC2LoZSyl462gMIbSgURWUXRQ04KKrJkIIgTBWybXY+hVMWIVSpGkoLDsLwzDU5047To+OKJau+ZV49dADQudSRJzt5hARBxS3Oo0Xk5ZEVEoxBg1rJaLZTCmJKqtSp/omQKkXe56nWnlouSk0O1bq7EJVCXHAUmt6ysr0/NNMOlzba/BqoweEzqWUlhOYpmld5+dWPLSs8ZeW5uCGlJnIRVEUmxKSba0+VI2U7OvsQqRazS/W8VDLoxedxuc+/Qy9LGl/9IDQuZTSPrlDCDV52C7iaZrW3oVVIj0o1Te6+iosuYIql8a6m7AkGWsg8are3DogVXUVUQEoDqdHt4l9k2Fv9IDQuZRxHBHP9Z/EqsZB8cCwOcBTrrkDbe7NrU4gW2nLCr+gsLwEDguyFihJWHIHZzsTi56qiBAEyBnpri17oweEzuclhNCqE2GaJjaboZYwh4GoAZ8zQ+trWGYMqWkkMgQYAh4vujatdQZmgK0zkSUonG1VKjlNzLvTa30NXk30gNC5lJzzmiNQVYYhMKdd/aYKtkz9tekvAiklhmGoCsvFsJRbD0MADeuFX2sOlvtneooppQtWb/PJEbvjo2t6BV599IDQuZSiCR9GNG7W4iDh7KLGDW8NT6UUNLxhL8EAAA8cSURBVCxqSrYGEXHD5gkwsMLQFJTr9xePhtY3gbUqZ8FKxtOO7WbD6e0Xru01eLXRA0LnUpZmo2UKb2aIF8Qdy2dyZ2ZWZwFWxVWxunTwYoAi4aywaJ7nVWHJFuOW1iNVdy2W+gTHcNJu18RWO/ugB4TOpSxr+xgjGmpdQlmcm1rZ8bI7sPYwXMgDNP8Fr2KrpZQ1WJgZoRS8ZIrnswKn5uA0jiPTNDEOgRc+/cx1vgyvKnpA6FyKTKeYGHNJWNH1wgYwap2Am+HN6LV+8lc59SDa7NwElzpbiKK4sC45XCCV6vdguZ3rNZloZoyxFiSdvPTCmTJT50rpAaFzKWmeCQhy7uJW5OJSQZsdW9BakYjhJeFpRnzpbzgrYooaWm6hLguGoV7053chzicy87Qjn758wTauc3X0gNC5lGjGEEa0XdzuTlZdfRy1LQnMDMmGFifSlgbjSDbYbFpC0vLq7JxzrlLt1IrG5UJflh91+1FxMmE4YFQlhj472Ac9IHQu5eToiJJymxEESnFCKYQwYN60dVrBUtVLDMzmVXE5zQwayNO82r8BWN4hnrBcty+XSsgQAsMwkFItk845gQeiQp6PKVOvRdgHPSB0LuX46KXa1uzGNE31oBjZDLcJW4qJnGrDJtXWDcvgzT6eQrG0SqPFOLbtRlmDQSml5hOmKpeWc9VICKGawChCOj3G+7/rldNf4c6lvPT8MxRTiktTQnasaFU6ArJlNAiG1R0Im4iqWAEdtAYFr9ZtKnGtTjQzfBFAaTsZmK/NT6tku1cPiBgCLx3dZsBb62TnqugBoXMpJy++QBBFW+Jw2RZMKYEGhjjiRks6CjFsKR4Yxy2WLjpALzMEI9YgUTgrXmoX/xl11jDEiOeCu/HMp34XOOuJ6FwN/dXtXMrtF1+o9QJxXP0co9ZEYcm2yqctpcjTfAcw5jJjfmbJVl2eHJWIiOMUcjq9UPQEtUKx2EQp1QNCBEIUypy4/fyzdabSjV+vlB4QOpdy/JnbVdqs7GpA0Oq8NKWCBsFZtgKrTsJmc1BFThzcAtnPZglCfZx3d2oJ8zgS5ExHkUWnkersJEFJuTDvJkSd+eglsla5987V0QNC5wKrDqI7mo7QKJjYWdORSt0lOLccWDoiS/aznAAgVlujvYCVhHip9m5NJyGEcGGrEcCogYFWqDSESBDl9OjlagGnPYdwldxTQBCRR0Tkp0TkYyLyURH5ehF5jYi8V0R+u90+2s4VEfkBEXlSRH5TRN5ytX9C534SEdRnRAI3NhskFcYwghXynEjTTLG57ixQ1/9pmqvgqtSeBluEUwI4CdF0VuF4zpWp5Fx3KswwjDiMRA8EHSjueMqkMtceiXLCGA5bf0TnqrjXGcK/AX7e3b+Sauv2UeBdwPvc/c3A+9pjgG8B3ty+3gn84H0dcedKyWYEjUg+Zbc7JoS6a7DUCmgMWBEknFUULrsD3qzbzqoWK6UULNeZgzh1R6HN/Nd+CKlLhyy16jE4hLEaxppAyTNW5rU/onM13Iv78y3gbcCPALj77O63gW8F3t1Oezfwbe3+twI/6pVfAR5ZbOM7Dz6mRkqF557+JOoK7rWewGtxkmpE47hqJSydiaVU67ZBA2JO4GxGsKgrL/mCJZm4KCyrKm7G7vQEWVSdg5J3p3V2kBPiGZtPV4eoztVwLzOErwCeA/6jiPyGiPz7Zgv/usXmvd2+tp3/pcCnzv38U+3YBUTknSLyQRH54PPPP/+K/ojO/cNlwHTgDz72EViSht7kz5prk59rUQZQpZqvnCtBNgOK1fqDFgDStKuaiUFbLgEMYzfvVncnd2+W80oIwyqvGrJyujtuCtCdq+JeAkIE3gL8oLt/DXCHs+XB3bhbDP+cd9Hdf9jd3+rub3388cfvabCdq0dK3S78vY9/BGD1SJCgFIdSnJQKKlUxOcZY6wliwARO56lpJtqFBCPNe6GkDObkORE0ggvbzQFmVlWWYF2KuEEIS/NT4cXnnukNTlfMvQSEp4Cn3P0D7fFPUQPEp5elQLt99tz5bzz3828Anr4/w+1cNUEBEU5ffn7taHT3asQSztSSzl+YpRRKqpoG47Ze3Iuu4mr1RgENxBhX7cXzCcblFqp2o5yrZBRq3uD2i1056ar5ggHB3Z8BPiUif6Yd+kbg/wLvAd7Rjr0D+Jl2/z3Ad7Xdhq8DXlqWFp0HH8PRMjMUQ2l1BGIUCtlq0tGLUXIi50xKaf1Ez7nKnpU5UfA1eEjY4F6t34qDIWQr68+UUkjzxHy6w3N9vuxWFZqLUdwoeeb5Z56m75RfLfdqB/8PgR8TkRH4BPDd1HfmJ0Xke4DfB76jnftzwNuBJ4GTdm7njwnqA8//wZOIFUxhDNWrEatBYRg3iNbAkVI6M1sJTXItZ3QIuFO3IUWY046oYZ05qNY8w5JcXNSWh2Gg0LQRilFywXBKKui44eXPPIdz9zVp5/5wTwHB3T8EvPUu3/rGu5zrwPe+wnF1rokghQ//z1/AUbwkijoihUEOEDfcDEEpVojbgd1uxziODD6gxYjjBlvETfKMIhQvYENbZhhzSlV81QTPuTo1uZPKXGcSBbI7LoGSZqo9Q0ZOTzGB0NMIV8a9zhA6rxJm4Jnff5LBDB3qhRjjeCZ51mYFIQRSSsRYuxh3ux3DMGAGcRyaVdtQzVpUKblVN4pXc1dTPM9YKWSv4q2enVJqsZKYU3IipYS54Cj55M66ndm5GnpA6FzEhHB6xFQKUQqbcSBnq+5J5sTAWn9wVmPgaxmyeCG5o7H5LhQjDCNQi5CqlyPklAg0Uxcg4xRvOxDTTDZvLlB1i2oumVJ2WEm94/EK6QGhc4HkSmHggKn6JTgEFVKaUa2iqsWs2ryZkeaZ2HYfQgi4GCVnyDTHJ6Wked1BEJw0VVPXqVRBFBHFSqp9D9kQUSTUJy8lU7xQTPGc8BDBe/nyVdEDQucC6eXnUKkeC9Is2ERAUUiGBQht63AJArvdjmEc18dLO/P51uYliRj0nHqyVoXlaZk5iJDdSKUmE9f2aqszkjzNBPG7VLV07hc9IHQu8MSv/C92x0d4LAyl7v+LVJPWKBBabULOGYFVJ2E+d1EvdQYhKma1MKkszs8sVY+GFYOWLzCpASC71SKnnLECjmBWSMkpkiFb73i8QvpirANAFUJznvjfv1in6l7t2uHsYk6pJvlyStWPwZ15ntcGJWD9VC+lME+JnErtigyxNkeFgLkzTRNmxpQzJkJpzk9mZfV4dBVyrvmEgmMlg/bmpqukzxA6QBVGjgEk1TV7cKEUI2dqdaEZIcaL1YuLhXubFSxlyjlnxnH8LA1FsJKxUpORQZVihoZQg4g7aZ4vFBmsBU8FdNg2c9nqBdm5GnpA6AAQTCnMpNNjojtmAupIqxIctVYbLkFgaXteHp8Jr1Zt5GmayGlme3BIKoZSL+QloAB4m3XEGMlmtfagCKfzxDwnVAvmgTnPFJ9x3eBe6BPbq6O/sh0AZFSef+r36sWqgrnjHnAL4IGczroZl3Lj5cJe7i/9C0vJ8nlV5eK22rgtxxcVppwzaZ7X/obleaYprcuRYsacE8XStb1Grwb6DKEDQBLn197/S8wlE0VRFXbzKVvdEjWiGshWyKdTLTEuBUQorZchF1+XCdJqFABKSzaWwoXahWWnYQkM7t4MXepnlIhgLhQ3UsnMrgxjpHc/Xy09IHQA0CJ87BOfYNNUjR1qrUG7cN0LWCDEWGcPVncIxnFcS5Jznok6rPkFVcXcEJbf4WuKYGmKAhBVcipYW1IUhzkXUp4wAR0CqcDsytYyc9js+dV59SAPQn+5iBwBH7/ucQCPA9et1tLHcMaDMI4HYQzwysfxZe7+JV/opAdlhvBxd79b89ReEZEPXvc4+hgerHE8CGPY5zh6UrHT6az0gNDpdFYelIDww9c9gMaDMI4+hjMehHE8CGOAPY3jgUgqdjqdB4MHZYbQ6XQeAK49IIjI3xSRjzfrt88n7/5Kn+c/iMizIvLEuWN7taMTkTeKyC83O7zfEpF/dE3j2IrIr4rIh9s4/kU7/uUi8oE2jp9oGpqIyKY9frJ9/033Yxztd4fm9/Gz1ziGT4rIR0TkQyLywXZs3+/Jg2GXuBSRXMcXEIDfoZrBjMCHga+6oud6G1U+/olzx/4V8K52/13Av2z33w78D2qrzdcBH7hPY3g98JZ2/yHg/wFfdQ3jEOBmuz8AH2i//yeB72zHfwj4++3+PwB+qN3/TuAn7uP78k+AHwd+tj2+jjF8Enj8s47t+z15N/D32v0ReGTfY3D3aw8IXw/8wrnH3wd83xU+35s+KyB8HHh9u/96aj0EwL8D/s7dzrvP4/kZ4G9c5ziAQ+D/AH+RWvgSP/u9AX4B+Pp2P7bz5D489xuovqB/DfjZ9g++1zG033e3gLC39wS4BfzuZ/891/F/cd1LhnuyfbtCXpEd3SuhTXm/hvrpvPdxtKn6h6gGO++lztRuu3u+y3Ot42jffwl47D4M4/uBfwosmmiPXcMYoFZq/6KI/LqIvLMd2+d7ciV2iV8M1x0Q7sn27Rq40nGJyE3gvwL/2N1fvo5xuHtx96+mfkp/LfBnP89z3fdxiMjfAp51918/f3ifYzjHN7j7W6jO5d8rIm/7POdexTiuxC7xi+G6A8J1277t3Y5ORAZqMPgxd/9v1zWOBa9O3u+nrkUfEZGlnP38c63jaN9/GPjMK3zqbwD+toh8EvjP1GXD9+95DAC4+9Pt9lngp6kBcp/vyQNjl3jdAeHXgDe3zPJITRa9Z4/Pv1c7OhER4EeAj7r7v77GcXyJiDzS7h8Afx34KPDLwLdfMo5lfN8O/JK3xesXi7t/n7u/wd3fRH3ff8nd/+4+xwAgIjdE5KHlPvBNwBPs8T3xB8ku8X4kIl5hQuXt1Gz77wD/7Aqf5z8BfwgkaoT9Huoa9H3Ab7fb17RzBfi3bUwfAd56n8bwl6hTu98EPtS+3n4N4/jzwG+0cTwB/PN2/CuAX6Xa8P0XYNOOb9vjJ9v3v+I+vzd/hbNdhr2OoT3fh9vXby3/g9fwnnw18MH2nvx34NF9j8Hde6Vip9M547qXDJ1O5wGiB4ROp7PSA0Kn01npAaHT6az0gNDpdFZ6QOh0Ois9IHQ6nZUeEDqdzsr/B18Yuz2J19pZAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "\n",
    "my_image = \"peace-sign.jpg\"\n",
    "\n",
    "\n",
    "# We preprocess your image to fit your algorithm.\n",
    "fname = \"C:/Users/ssharan/Desktop/tensorflow/\" + my_image\n",
    "print(fname)\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T\n",
    "print(my_image.shape[0])\n",
    "\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)))"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}