diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/Deep Neural Network - Cat Image Classifier.ipynb b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/Deep Neural Network - Cat Image Classifier.ipynb
new file mode 100644
index 0000000..8af9e1f
--- /dev/null
+++ b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/Deep Neural Network - Cat Image Classifier.ipynb	
@@ -0,0 +1,1187 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Deep Neural Network - Cat Image Classifier\n",
+    "\n",
+    "By the time you complete this notebook, you will have finished the deep neural network classifier to recognize cats.\n",
+    "\n",
+    "To build your cat/not-a-cat classifier, you'll use the functions from the classifier to recognize cats to build a deep network. Hopefully, you'll see an improvement in accuracy over your previous logistic regression classifier implementation.\n",
+    "\n",
+    "**After this project you will be able to:**\n",
+    "\n",
+    "- Build and train a deep L-layer neural network, and apply it to supervised learning\n",
+    "\n",
+    "Let's get started!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table of Contents\n",
+    "- [1 - Packages](#1)\n",
+    "- [2 - Load and Process the Dataset](#2)\n",
+    "- [3 - Model Architecture](#3)\n",
+    "    - [3.1 - 2-layer Neural Network](#3-1)\n",
+    "    - [3.2 - L-layer Deep Neural Network](#3-2)\n",
+    "    - [3.3 - General Methodology](#3-3)\n",
+    "- [4 - Two-layer Neural Network](#4)\n",
+    "    - [Exercise 1 - two_layer_model](#ex-1)\n",
+    "    - [4.1 - Train the model](#4-1)\n",
+    "- [5 - L-layer Neural Network](#5)\n",
+    "    - [Exercise 2 - L_layer_model](#ex-2)\n",
+    "    - [5.1 - Train the model](#5-1)\n",
+    "- [6 - Results Analysis](#6)\n",
+    "- [7 - Test with your own image (optional/ungraded exercise)](#7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='1'></a>\n",
+    "## 1 - Packages"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Begin by importing all the packages you'll need during this assignment. \n",
+    "\n",
+    "- [numpy](https://www.numpy.org/) is the fundamental package for scientific computing with Python.\n",
+    "- [matplotlib](http://matplotlib.org) is a library to plot graphs in Python.\n",
+    "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n",
+    "- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end.\n",
+    "- `dnn_app_utils` provides the functions implemented in the \"Building your Deep Neural Network: Step by Step\" assignment to this notebook.\n",
+    "- `np.random.seed(1)` is used to keep all the random function calls consistent. It helps grade your work - so please don't change it! "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\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",
+    "from dnn_app_utils_v3 import *\n",
+    "from public_tests import *\n",
+    "\n",
+    "%matplotlib inline\n",
+    "plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\n",
+    "plt.rcParams['image.interpolation'] = 'nearest'\n",
+    "plt.rcParams['image.cmap'] = 'gray'\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "np.random.seed(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='2'></a>\n",
+    "## 2 - Load and Process the Dataset\n",
+    "\n",
+    "You'll be using the same \"Cat vs non-Cat\" dataset as in \"Logistic Regression as a Neural Network\" (Assignment 2). The model you built back then had 70% test accuracy on classifying cat vs non-cat images. Hopefully, your new model will perform even better!\n",
+    "\n",
+    "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n",
+    "    - a training set of `m_train` images labelled as cat (1) or non-cat (0)\n",
+    "    - a test set of `m_test` images labelled as cat and non-cat\n",
+    "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB).\n",
+    "\n",
+    "Let's get more familiar with the dataset. Load the data by running the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_x_orig, train_y, test_x_orig, test_y, classes = load_data()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following code will show you an image in the dataset. Feel free to change the index and re-run the cell multiple times to check out other images. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = 0. It's a non-cat picture.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Example of a picture\n",
+    "index = 10\n",
+    "plt.imshow(train_x_orig[index])\n",
+    "print (\"y = \" + str(train_y[0,index]) + \". It's a \" + classes[train_y[0,index]].decode(\"utf-8\") +  \" picture.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training examples: 209\n",
+      "Number of testing examples: 50\n",
+      "Each image is of size: (64, 64, 3)\n",
+      "train_x_orig shape: (209, 64, 64, 3)\n",
+      "train_y shape: (1, 209)\n",
+      "test_x_orig shape: (50, 64, 64, 3)\n",
+      "test_y shape: (1, 50)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Explore your dataset \n",
+    "m_train = train_x_orig.shape[0]\n",
+    "num_px = train_x_orig.shape[1]\n",
+    "m_test = test_x_orig.shape[0]\n",
+    "\n",
+    "print (\"Number of training examples: \" + str(m_train))\n",
+    "print (\"Number of testing examples: \" + str(m_test))\n",
+    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
+    "print (\"train_x_orig shape: \" + str(train_x_orig.shape))\n",
+    "print (\"train_y shape: \" + str(train_y.shape))\n",
+    "print (\"test_x_orig shape: \" + str(test_x_orig.shape))\n",
+    "print (\"test_y shape: \" + str(test_y.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As usual, you reshape and standardize the images before feeding them to the network. The code is given in the cell below.\n",
+    "\n",
+    "<img src=\"images/imvectorkiank.png\" style=\"width:450px;height:300px;\">\n",
+    "<caption><center><font color='purple'><b>Figure 1</b>: Image to vector conversion.</font></center></caption>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train_x's shape: (12288, 209)\n",
+      "test_x's shape: (12288, 50)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Reshape the training and test examples \n",
+    "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T   # The \"-1\" makes reshape flatten the remaining dimensions\n",
+    "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n",
+    "\n",
+    "# Standardize data to have feature values between 0 and 1.\n",
+    "train_x = train_x_flatten/255.\n",
+    "test_x = test_x_flatten/255.\n",
+    "\n",
+    "print (\"train_x's shape: \" + str(train_x.shape))\n",
+    "print (\"test_x's shape: \" + str(test_x.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Note**:\n",
+    "$12,288$ equals $64 \\times 64 \\times 3$, which is the size of one reshaped image vector."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='3'></a>\n",
+    "## 3 - Model Architecture"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='3-1'></a>\n",
+    "### 3.1 - 2-layer Neural Network\n",
+    "\n",
+    "Now that you're familiar with the dataset, it's time to build a deep neural network to distinguish cat images from non-cat images!\n",
+    "\n",
+    "You're going to build two different models:\n",
+    "\n",
+    "- A 2-layer neural network\n",
+    "- An L-layer deep neural network\n",
+    "\n",
+    "Then, you'll compare the performance of these models, and try out some different values for $L$. \n",
+    "\n",
+    "Let's look at the two architectures:\n",
+    "\n",
+    "<img src=\"images/2layerNN_kiank.png\" style=\"width:650px;height:400px;\">\n",
+    "<caption><center><font color='purple'><b>Figure 2</b>: 2-layer neural network. <br> The model can be summarized as: INPUT -> LINEAR -> RELU -> LINEAR -> SIGMOID -> OUTPUT.</font></center></caption>\n",
+    "\n",
+    "<u><b>Detailed Architecture of Figure 2</b></u>:\n",
+    "- The input is a (64,64,3) image which is flattened to a vector of size $(12288,1)$. \n",
+    "- The corresponding vector: $[x_0,x_1,...,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ of size $(n^{[1]}, 12288)$.\n",
+    "- Then, add a bias term and take its relu to get the following vector: $[a_0^{[1]}, a_1^{[1]},..., a_{n^{[1]}-1}^{[1]}]^T$.\n",
+    "- Multiply the resulting vector by $W^{[2]}$ and add the intercept (bias). \n",
+    "- Finally, take the sigmoid of the result. If it's greater than 0.5, classify it as a cat.\n",
+    "\n",
+    "<a name='3-2'></a>\n",
+    "### 3.2 - L-layer Deep Neural Network\n",
+    "\n",
+    "It's pretty difficult to represent an L-layer deep neural network using the above representation. However, here is a simplified network representation:\n",
+    "\n",
+    "<img src=\"images/LlayerNN_kiank.png\" style=\"width:650px;height:400px;\">\n",
+    "<caption><center><font color='purple'><b>Figure 3</b>: L-layer neural network. <br> The model can be summarized as: [LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID</font></center></caption>\n",
+    "\n",
+    "<u><b>Detailed Architecture of Figure 3</b></u>:\n",
+    "- The input is a (64,64,3) image which is flattened to a vector of size (12288,1).\n",
+    "- The corresponding vector: $[x_0,x_1,...,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ and then you add the intercept $b^{[1]}$. The result is called the linear unit.\n",
+    "- Next, take the relu of the linear unit. This process could be repeated several times for each $(W^{[l]}, b^{[l]})$ depending on the model architecture.\n",
+    "- Finally, take the sigmoid of the final linear unit. If it is greater than 0.5, classify it as a cat.\n",
+    "\n",
+    "<a name='3-3'></a>\n",
+    "### 3.3 - General Methodology\n",
+    "\n",
+    "As usual, you'll follow the Deep Learning methodology to build the model:\n",
+    "\n",
+    "1. Initialize parameters / Define hyperparameters\n",
+    "2. Loop for num_iterations:\n",
+    "    a. Forward propagation\n",
+    "    b. Compute cost function\n",
+    "    c. Backward propagation\n",
+    "    d. Update parameters (using parameters, and grads from backprop) \n",
+    "3. Use trained parameters to predict labels\n",
+    "\n",
+    "Now go ahead and implement those two models!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='4'></a>\n",
+    "## 4 - Two-layer Neural Network\n",
+    "\n",
+    "<a name='ex-1'></a>\n",
+    "### Exercise 1 - two_layer_model \n",
+    "\n",
+    "Use the helper functions you have implemented in the previous assignment to build a 2-layer neural network with the following structure: *LINEAR -> RELU -> LINEAR -> SIGMOID*. The functions and their inputs are:\n",
+    "```python\n",
+    "def initialize_parameters(n_x, n_h, n_y):\n",
+    "    ...\n",
+    "    return parameters \n",
+    "def linear_activation_forward(A_prev, W, b, activation):\n",
+    "    ...\n",
+    "    return A, cache\n",
+    "def compute_cost(AL, Y):\n",
+    "    ...\n",
+    "    return cost\n",
+    "def linear_activation_backward(dA, cache, activation):\n",
+    "    ...\n",
+    "    return dA_prev, dW, db\n",
+    "def update_parameters(parameters, grads, learning_rate):\n",
+    "    ...\n",
+    "    return parameters\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### CONSTANTS DEFINING THE MODEL ####\n",
+    "n_x = 12288     # num_px * num_px * 3\n",
+    "n_h = 7\n",
+    "n_y = 1\n",
+    "layers_dims = (n_x, n_h, n_y)\n",
+    "learning_rate = 0.0075"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "db8e38ac17a149dc8e73efffd5cfbecf",
+     "grade": false,
+     "grade_id": "cell-46e7e26fe75ece95",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: two_layer_model\n",
+    "\n",
+    "def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
+    "    \"\"\"\n",
+    "    Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.\n",
+    "    \n",
+    "    Arguments:\n",
+    "    X -- input data, of shape (n_x, number of examples)\n",
+    "    Y -- true \"label\" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)\n",
+    "    layers_dims -- dimensions of the layers (n_x, n_h, n_y)\n",
+    "    num_iterations -- number of iterations of the optimization loop\n",
+    "    learning_rate -- learning rate of the gradient descent update rule\n",
+    "    print_cost -- If set to True, this will print the cost every 100 iterations \n",
+    "    \n",
+    "    Returns:\n",
+    "    parameters -- a dictionary containing W1, W2, b1, and b2\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    np.random.seed(1)\n",
+    "    grads = {}\n",
+    "    costs = []                              # to keep track of the cost\n",
+    "    m = X.shape[1]                           # number of examples\n",
+    "    (n_x, n_h, n_y) = layers_dims\n",
+    "    \n",
+    "    # Initialize parameters dictionary, by calling one of the functions you'd previously implemented\n",
+    "    #(≈ 1 line of code)\n",
+    "    # parameters = ...\n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    parameters = initialize_parameters(layers_dims[0], layers_dims[1], layers_dims[2])\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "    # Get W1, b1, W2 and b2 from the dictionary parameters.\n",
+    "    W1 = parameters[\"W1\"]\n",
+    "    b1 = parameters[\"b1\"]\n",
+    "    W2 = parameters[\"W2\"]\n",
+    "    b2 = parameters[\"b2\"]\n",
+    "    \n",
+    "    # Loop (gradient descent)\n",
+    "\n",
+    "    for i in range(0, num_iterations):\n",
+    "\n",
+    "        # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: \"X, W1, b1, W2, b2\". Output: \"A1, cache1, A2, cache2\".\n",
+    "        #(≈ 2 lines of code)\n",
+    "        # A1, cache1 = ...\n",
+    "        # A2, cache2 = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        A1, cache1 = linear_activation_forward(X, W1, b1, activation = \"relu\")\n",
+    "        A2, cache2 = linear_activation_forward(A1, W2, b2, activation = \"sigmoid\") \n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "        \n",
+    "        # Compute cost\n",
+    "        #(≈ 1 line of code)\n",
+    "        # cost = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        cost = compute_cost(A2, Y)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "        \n",
+    "        # Initializing backward propagation\n",
+    "        dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))\n",
+    "        \n",
+    "        # Backward propagation. Inputs: \"dA2, cache2, cache1\". Outputs: \"dA1, dW2, db2; also dA0 (not used), dW1, db1\".\n",
+    "        #(≈ 2 lines of code)\n",
+    "        # dA1, dW2, db2 = ...\n",
+    "        # dA0, dW1, db1 = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        dA1, dW2, db2 = linear_activation_backward(dA2, cache2, activation = \"sigmoid\")\n",
+    "        dA0, dW1, db1 = linear_activation_backward(dA1, cache1, activation = \"relu\")\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "        \n",
+    "        # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2\n",
+    "        grads['dW1'] = dW1\n",
+    "        grads['db1'] = db1\n",
+    "        grads['dW2'] = dW2\n",
+    "        grads['db2'] = db2\n",
+    "        \n",
+    "        # Update parameters.\n",
+    "        #(approx. 1 line of code)\n",
+    "        # parameters = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "\n",
+    "        # Retrieve W1, b1, W2, b2 from parameters\n",
+    "        W1 = parameters[\"W1\"]\n",
+    "        b1 = parameters[\"b1\"]\n",
+    "        W2 = parameters[\"W2\"]\n",
+    "        b2 = parameters[\"b2\"]\n",
+    "        \n",
+    "        # Print the cost every 100 iterations\n",
+    "        if print_cost and i % 100 == 0 or i == num_iterations - 1:\n",
+    "            print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n",
+    "        if i % 100 == 0 or i == num_iterations:\n",
+    "            costs.append(cost)\n",
+    "\n",
+    "    return parameters, costs\n",
+    "\n",
+    "def plot_costs(costs, learning_rate=0.0075):\n",
+    "    plt.plot(np.squeeze(costs))\n",
+    "    plt.ylabel('cost')\n",
+    "    plt.xlabel('iterations (per hundreds)')\n",
+    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "c4efa978eb920cd5de40eccf4c40c6e8",
+     "grade": true,
+     "grade_id": "cell-7599b81fb37ae26a",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost after iteration 1: 0.6926114346158595\n",
+      "Cost after first iteration: 0.693049735659989\n",
+      "Cost after iteration 1: 0.6915746967050506\n",
+      "Cost after iteration 1: 0.6915746967050506\n",
+      "Cost after iteration 1: 0.6915746967050506\n",
+      "Cost after iteration 2: 0.6524135179683452\n",
+      "\u001b[92m All tests passed.\n"
+     ]
+    }
+   ],
+   "source": [
+    "parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2, print_cost=False)\n",
+    "\n",
+    "print(\"Cost after first iteration: \" + str(costs[0]))\n",
+    "\n",
+    "two_layer_model_test(two_layer_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected output:**\n",
+    "\n",
+    "```\n",
+    "cost after iteration 1 must be around 0.69\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='4-1'></a>\n",
+    "### 4.1 - Train the model \n",
+    "\n",
+    "If your code passed the previous cell, run the cell below to train your parameters. \n",
+    "\n",
+    "- The cost should decrease on every iteration. \n",
+    "\n",
+    "- It may take up to 5 minutes to run 2500 iterations. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost after iteration 0: 0.693049735659989\n",
+      "Cost after iteration 100: 0.6464320953428849\n",
+      "Cost after iteration 200: 0.6325140647912677\n",
+      "Cost after iteration 300: 0.6015024920354665\n",
+      "Cost after iteration 400: 0.5601966311605747\n",
+      "Cost after iteration 500: 0.5158304772764729\n",
+      "Cost after iteration 600: 0.4754901313943325\n",
+      "Cost after iteration 700: 0.43391631512257495\n",
+      "Cost after iteration 800: 0.4007977536203886\n",
+      "Cost after iteration 900: 0.3580705011323798\n",
+      "Cost after iteration 1000: 0.3394281538366413\n",
+      "Cost after iteration 1100: 0.30527536361962654\n",
+      "Cost after iteration 1200: 0.2749137728213015\n",
+      "Cost after iteration 1300: 0.2468176821061484\n",
+      "Cost after iteration 1400: 0.19850735037466102\n",
+      "Cost after iteration 1500: 0.17448318112556638\n",
+      "Cost after iteration 1600: 0.1708076297809692\n",
+      "Cost after iteration 1700: 0.11306524562164715\n",
+      "Cost after iteration 1800: 0.09629426845937156\n",
+      "Cost after iteration 1900: 0.0834261795972687\n",
+      "Cost after iteration 2000: 0.07439078704319085\n",
+      "Cost after iteration 2100: 0.06630748132267933\n",
+      "Cost after iteration 2200: 0.05919329501038172\n",
+      "Cost after iteration 2300: 0.053361403485605606\n",
+      "Cost after iteration 2400: 0.04855478562877019\n",
+      "Cost after iteration 2499: 0.04421498215868956\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2880x2880 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)\n",
+    "plot_costs(costs, learning_rate)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**:\n",
+    "<table> \n",
+    "    <tr>\n",
+    "        <td> <b>Cost after iteration 0</b></td>\n",
+    "        <td> 0.6930497356599888 </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td> <b>Cost after iteration 100</b></td>\n",
+    "        <td> 0.6464320953428849 </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td> <b>...</b></td>\n",
+    "        <td> ... </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td> <b>Cost after iteration 2499</b></td>\n",
+    "        <td> 0.04421498215868956 </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Nice!** You successfully trained the model. Good thing you built a vectorized implementation! Otherwise it might have taken 10 times longer to train this.\n",
+    "\n",
+    "Now, you can use the trained parameters to classify images from the dataset. To see your predictions on the training and test sets, run the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.9999999999999998\n"
+     ]
+    }
+   ],
+   "source": [
+    "predictions_train = predict(train_x, train_y, parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**:\n",
+    "<table> \n",
+    "    <tr>\n",
+    "        <td> <b>Accuracy</b></td>\n",
+    "        <td> 0.9999999999999998 </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.72\n"
+     ]
+    }
+   ],
+   "source": [
+    "predictions_test = predict(test_x, test_y, parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**:\n",
+    "\n",
+    "<table> \n",
+    "    <tr>\n",
+    "        <td> <b>Accuracy</b></td>\n",
+    "        <td> 0.72 </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Congratulations! It seems that your 2-layer neural network has better performance (72%) than the logistic regression implementation (70%, assignment week 2). Let's see if you can do even better with an $L$-layer model.\n",
+    "\n",
+    "**Note**: You may notice that running the model on fewer iterations (say 1500) gives better accuracy on the test set. This is called \"early stopping\" and you'll hear more about it in the next course. Early stopping is a way to prevent overfitting. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='5'></a>\n",
+    "## 5 - L-layer Neural Network\n",
+    "\n",
+    "<a name='ex-2'></a>\n",
+    "### Exercise 2 - L_layer_model \n",
+    "\n",
+    "Use the helper functions you implemented previously to build an $L$-layer neural network with the following structure: *[LINEAR -> RELU]$\\times$(L-1) -> LINEAR -> SIGMOID*. The functions and their inputs are:\n",
+    "```python\n",
+    "def initialize_parameters_deep(layers_dims):\n",
+    "    ...\n",
+    "    return parameters \n",
+    "def L_model_forward(X, parameters):\n",
+    "    ...\n",
+    "    return AL, caches\n",
+    "def compute_cost(AL, Y):\n",
+    "    ...\n",
+    "    return cost\n",
+    "def L_model_backward(AL, Y, caches):\n",
+    "    ...\n",
+    "    return grads\n",
+    "def update_parameters(parameters, grads, learning_rate):\n",
+    "    ...\n",
+    "    return parameters\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### CONSTANTS ###\n",
+    "layers_dims = [12288, 20, 7, 5, 1] #  4-layer model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "8b444dd257b73f67117533b4265ba6b4",
+     "grade": false,
+     "grade_id": "cell-dd8ea98cb7dac175",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: L_layer_model\n",
+    "\n",
+    "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
+    "    \"\"\"\n",
+    "    Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.\n",
+    "    \n",
+    "    Arguments:\n",
+    "    X -- input data, of shape (n_x, number of examples)\n",
+    "    Y -- true \"label\" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)\n",
+    "    layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).\n",
+    "    learning_rate -- learning rate of the gradient descent update rule\n",
+    "    num_iterations -- number of iterations of the optimization loop\n",
+    "    print_cost -- if True, it prints the cost every 100 steps\n",
+    "    \n",
+    "    Returns:\n",
+    "    parameters -- parameters learnt by the model. They can then be used to predict.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    np.random.seed(1)\n",
+    "    costs = []                         # keep track of cost\n",
+    "    \n",
+    "    # Parameters initialization.\n",
+    "    #(≈ 1 line of code)\n",
+    "    # parameters = ...\n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    parameters = initialize_parameters_deep(layers_dims)\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "    # Loop (gradient descent)\n",
+    "    for i in range(0, num_iterations):\n",
+    "\n",
+    "        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.\n",
+    "        #(≈ 1 line of code)\n",
+    "        # AL, caches = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        AL, caches = L_model_forward(X, parameters)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "        \n",
+    "        # Compute cost.\n",
+    "        #(≈ 1 line of code)\n",
+    "        # cost = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        cost = compute_cost(AL, Y)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "        # Backward propagation.\n",
+    "        #(≈ 1 line of code)\n",
+    "        # grads = ...    \n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        grads = L_model_backward(AL, Y, caches)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    " \n",
+    "        # Update parameters.\n",
+    "        #(≈ 1 line of code)\n",
+    "        # parameters = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "                \n",
+    "        # Print the cost every 100 iterations\n",
+    "        if print_cost and i % 100 == 0 or i == num_iterations - 1:\n",
+    "            print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n",
+    "        if i % 100 == 0 or i == num_iterations:\n",
+    "            costs.append(cost)\n",
+    "    \n",
+    "    return parameters, costs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "1f74e4d164e9274bfa921ff2ce310c93",
+     "grade": true,
+     "grade_id": "cell-ec1d0c26f291cd5f",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost after iteration 0: 0.7717493284237686\n",
+      "Cost after first iteration: 0.7717493284237686\n",
+      "Cost after iteration 1: 0.7070709008912569\n",
+      "Cost after iteration 1: 0.7070709008912569\n",
+      "Cost after iteration 1: 0.7070709008912569\n",
+      "Cost after iteration 2: 0.7063462654190897\n",
+      "\u001b[92m All tests passed.\n"
+     ]
+    }
+   ],
+   "source": [
+    "parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 1, print_cost = False)\n",
+    "\n",
+    "print(\"Cost after first iteration: \" + str(costs[0]))\n",
+    "\n",
+    "L_layer_model_test(L_layer_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='5-1'></a>\n",
+    "### 5.1 - Train the model \n",
+    "\n",
+    "If your code passed the previous cell, run the cell below to train your model as a 4-layer neural network. \n",
+    "\n",
+    "- The cost should decrease on every iteration. \n",
+    "\n",
+    "- It may take up to 5 minutes to run 2500 iterations. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost after iteration 0: 0.7717493284237686\n",
+      "Cost after iteration 100: 0.6720534400822914\n",
+      "Cost after iteration 200: 0.6482632048575212\n",
+      "Cost after iteration 300: 0.6115068816101356\n",
+      "Cost after iteration 400: 0.5670473268366111\n",
+      "Cost after iteration 500: 0.5401376634547801\n",
+      "Cost after iteration 600: 0.5279299569455267\n",
+      "Cost after iteration 700: 0.4654773771766851\n",
+      "Cost after iteration 800: 0.369125852495928\n",
+      "Cost after iteration 900: 0.39174697434805344\n",
+      "Cost after iteration 1000: 0.31518698886006163\n",
+      "Cost after iteration 1100: 0.2726998441789385\n",
+      "Cost after iteration 1200: 0.23741853400268137\n",
+      "Cost after iteration 1300: 0.19960120532208644\n",
+      "Cost after iteration 1400: 0.18926300388463307\n",
+      "Cost after iteration 1500: 0.16118854665827753\n",
+      "Cost after iteration 1600: 0.14821389662363316\n",
+      "Cost after iteration 1700: 0.13777487812972944\n",
+      "Cost after iteration 1800: 0.1297401754919012\n",
+      "Cost after iteration 1900: 0.12122535068005211\n",
+      "Cost after iteration 2000: 0.11382060668633713\n",
+      "Cost after iteration 2100: 0.10783928526254133\n",
+      "Cost after iteration 2200: 0.10285466069352679\n",
+      "Cost after iteration 2300: 0.10089745445261786\n",
+      "Cost after iteration 2400: 0.09287821526472398\n",
+      "Cost after iteration 2499: 0.08843994344170202\n"
+     ]
+    }
+   ],
+   "source": [
+    "parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**:\n",
+    "<table> \n",
+    "    <tr>\n",
+    "        <td> <b>Cost after iteration 0</b></td>\n",
+    "        <td> 0.771749 </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td> <b>Cost after iteration 100</b></td>\n",
+    "        <td> 0.672053 </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td> <b>...</b></td>\n",
+    "        <td> ... </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td> <b>Cost after iteration 2499</b></td>\n",
+    "        <td> 0.088439 </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.9856459330143539\n"
+     ]
+    }
+   ],
+   "source": [
+    "pred_train = predict(train_x, train_y, parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**:\n",
+    "\n",
+    "<table>\n",
+    "    <tr>\n",
+    "    <td>\n",
+    "        <b>Train Accuracy</b>\n",
+    "    </td>\n",
+    "    <td>\n",
+    "    0.985645933014\n",
+    "    </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.8\n"
+     ]
+    }
+   ],
+   "source": [
+    "pred_test = predict(test_x, test_y, parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**:\n",
+    "\n",
+    "<table> \n",
+    "    <tr>\n",
+    "        <td> <b>Test Accuracy</b></td>\n",
+    "        <td> 0.8 </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Congrats! It seems that your 4-layer neural network has better performance (80%) than your 2-layer neural network (72%) on the same test set. \n",
+    "\n",
+    "This is pretty good performance for this task. Nice job! \n",
+    "\n",
+    "In the next course on \"Improving deep neural networks,\" you'll be able to obtain even higher accuracy by systematically searching for better hyperparameters: learning_rate, layers_dims, or num_iterations, for example.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='6'></a>\n",
+    "##  6 - Results Analysis\n",
+    "\n",
+    "First, take a look at some images the L-layer model labeled incorrectly. This will show a few mislabeled images. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2880x2880 with 10 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print_mislabeled_images(classes, test_x, test_y, pred_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**A few types of images the model tends to do poorly on include:** \n",
+    "- Cat body in an unusual position\n",
+    "- Cat appears against a background of a similar color\n",
+    "- Unusual cat color and species\n",
+    "- Camera Angle\n",
+    "- Brightness of the picture\n",
+    "- Scale variation (cat is very large or small in image) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Congratulations on finishing this assignment! \n",
+    "\n",
+    "You just built and trained a deep L-layer neural network, and applied it in order to distinguish cats from non-cats, a very serious and important task in deep learning. ;)\n",
+    "\n",
+    "If you'd like to test out how closely you resemble a cat yourself, there's an optional ungraded exercise below, where you can test your own image."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='7'></a>\n",
+    "## 7 - Test with your own image (optional/ungraded exercise) ##\n",
+    "\n",
+    "From this point, if you so choose, you can use your own image to test  the output of your model. To do that follow these steps:\n",
+    "\n",
+    "1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
+    "2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
+    "3. Change your image's name in the following code\n",
+    "4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 1.0\n",
+      "y = 1.0, your L-layer model predicts a \"cat\" picture.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2880x2880 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "## START CODE HERE ##\n",
+    "my_image = \"my_image.jpg\" # change this to the name of your image file \n",
+    "my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)\n",
+    "## END CODE HERE ##\n",
+    "\n",
+    "fname = \"images/\" + my_image\n",
+    "image = np.array(Image.open(fname).resize((num_px, num_px)))\n",
+    "plt.imshow(image)\n",
+    "image = image / 255.\n",
+    "image = image.reshape((1, num_px * num_px * 3)).T\n",
+    "\n",
+    "my_predicted_image = predict(image, my_label_y, parameters)\n",
+    "\n",
+    "\n",
+    "print (\"y = \" + str(np.squeeze(my_predicted_image)) + \", your L-layer model predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**References**:\n",
+    "\n",
+    "- for auto-reloading external module: http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython"
+   ]
+  }
+ ],
+ "metadata": {
+  "coursera": {
+   "course_slug": "neural-networks-deep-learning",
+   "graded_item_id": "TSPse",
+   "launcher_item_id": "24mxX"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/dnn_app_utils_v3.cpython-37.pyc b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/dnn_app_utils_v3.cpython-37.pyc
new file mode 100644
index 0000000..742cdb6
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/dnn_app_utils_v3.cpython-37.pyc differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/public_tests.cpython-37.pyc b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/public_tests.cpython-37.pyc
new file mode 100644
index 0000000..ee92f3d
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/public_tests.cpython-37.pyc differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/test_utils.cpython-37.pyc b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/test_utils.cpython-37.pyc
new file mode 100644
index 0000000..4ac3477
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/__pycache__/test_utils.cpython-37.pyc differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/datasets/test_catvnoncat.h5 b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/datasets/test_catvnoncat.h5
new file mode 100644
index 0000000..f8dc438
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/datasets/test_catvnoncat.h5 differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/datasets/train_catvnoncat.h5 b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/datasets/train_catvnoncat.h5
new file mode 100644
index 0000000..5c131c6
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/datasets/train_catvnoncat.h5 differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/dnn_app_utils_v3.py b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/dnn_app_utils_v3.py
new file mode 100644
index 0000000..225b209
--- /dev/null
+++ b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/dnn_app_utils_v3.py	
@@ -0,0 +1,442 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import h5py
+
+
+def sigmoid(Z):
+    """
+    Implements the sigmoid activation in numpy
+    
+    Arguments:
+    Z -- numpy array of any shape
+    
+    Returns:
+    A -- output of sigmoid(z), same shape as Z
+    cache -- returns Z as well, useful during backpropagation
+    """
+    
+    A = 1/(1+np.exp(-Z))
+    cache = Z
+    
+    return A, cache
+
+def relu(Z):
+    """
+    Implement the RELU function.
+
+    Arguments:
+    Z -- Output of the linear layer, of any shape
+
+    Returns:
+    A -- Post-activation parameter, of the same shape as Z
+    cache -- a python dictionary containing "A" ; stored for computing the backward pass efficiently
+    """
+    
+    A = np.maximum(0,Z)
+    
+    assert(A.shape == Z.shape)
+    
+    cache = Z 
+    return A, cache
+
+
+def relu_backward(dA, cache):
+    """
+    Implement the backward propagation for a single RELU unit.
+
+    Arguments:
+    dA -- post-activation gradient, of any shape
+    cache -- 'Z' where we store for computing backward propagation efficiently
+
+    Returns:
+    dZ -- Gradient of the cost with respect to Z
+    """
+    
+    Z = cache
+    dZ = np.array(dA, copy=True) # just converting dz to a correct object.
+    
+    # When z <= 0, you should set dz to 0 as well. 
+    dZ[Z <= 0] = 0
+    
+    assert (dZ.shape == Z.shape)
+    
+    return dZ
+
+def sigmoid_backward(dA, cache):
+    """
+    Implement the backward propagation for a single SIGMOID unit.
+
+    Arguments:
+    dA -- post-activation gradient, of any shape
+    cache -- 'Z' where we store for computing backward propagation efficiently
+
+    Returns:
+    dZ -- Gradient of the cost with respect to Z
+    """
+    
+    Z = cache
+    
+    s = 1/(1+np.exp(-Z))
+    dZ = dA * s * (1-s)
+    
+    assert (dZ.shape == Z.shape)
+    
+    return dZ
+
+
+def load_data():
+    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
+    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
+    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels
+
+    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
+    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
+    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels
+
+    classes = np.array(test_dataset["list_classes"][:]) # the list of classes
+    
+    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
+    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
+    
+    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
+
+
+def initialize_parameters(n_x, n_h, n_y):
+    """
+    Argument:
+    n_x -- size of the input layer
+    n_h -- size of the hidden layer
+    n_y -- size of the output layer
+    
+    Returns:
+    parameters -- python dictionary containing your parameters:
+                    W1 -- weight matrix of shape (n_h, n_x)
+                    b1 -- bias vector of shape (n_h, 1)
+                    W2 -- weight matrix of shape (n_y, n_h)
+                    b2 -- bias vector of shape (n_y, 1)
+    """
+    
+    np.random.seed(1)
+    
+    W1 = np.random.randn(n_h, n_x)*0.01
+    b1 = np.zeros((n_h, 1))
+    W2 = np.random.randn(n_y, n_h)*0.01
+    b2 = np.zeros((n_y, 1))
+    
+    assert(W1.shape == (n_h, n_x))
+    assert(b1.shape == (n_h, 1))
+    assert(W2.shape == (n_y, n_h))
+    assert(b2.shape == (n_y, 1))
+    
+    parameters = {"W1": W1,
+                  "b1": b1,
+                  "W2": W2,
+                  "b2": b2}
+    
+    return parameters     
+
+
+def initialize_parameters_deep(layer_dims):
+    """
+    Arguments:
+    layer_dims -- python array (list) containing the dimensions of each layer in our network
+    
+    Returns:
+    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
+                    Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
+                    bl -- bias vector of shape (layer_dims[l], 1)
+    """
+    
+    np.random.seed(1)
+    parameters = {}
+    L = len(layer_dims)            # number of layers in the network
+
+    for l in range(1, L):
+        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) / np.sqrt(layer_dims[l-1]) #*0.01
+        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
+        
+        assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1]))
+        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))
+
+        
+    return parameters
+
+def linear_forward(A, W, b):
+    """
+    Implement the linear part of a layer's forward propagation.
+
+    Arguments:
+    A -- activations from previous layer (or input data): (size of previous layer, number of examples)
+    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
+    b -- bias vector, numpy array of shape (size of the current layer, 1)
+
+    Returns:
+    Z -- the input of the activation function, also called pre-activation parameter 
+    cache -- a python dictionary containing "A", "W" and "b" ; stored for computing the backward pass efficiently
+    """
+    
+    Z = W.dot(A) + b
+    
+    assert(Z.shape == (W.shape[0], A.shape[1]))
+    cache = (A, W, b)
+    
+    return Z, cache
+
+def linear_activation_forward(A_prev, W, b, activation):
+    """
+    Implement the forward propagation for the LINEAR->ACTIVATION layer
+
+    Arguments:
+    A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)
+    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
+    b -- bias vector, numpy array of shape (size of the current layer, 1)
+    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"
+
+    Returns:
+    A -- the output of the activation function, also called the post-activation value 
+    cache -- a python dictionary containing "linear_cache" and "activation_cache";
+             stored for computing the backward pass efficiently
+    """
+    
+    if activation == "sigmoid":
+        # Inputs: "A_prev, W, b". Outputs: "A, activation_cache".
+        Z, linear_cache = linear_forward(A_prev, W, b)
+        A, activation_cache = sigmoid(Z)
+    
+    elif activation == "relu":
+        # Inputs: "A_prev, W, b". Outputs: "A, activation_cache".
+        Z, linear_cache = linear_forward(A_prev, W, b)
+        A, activation_cache = relu(Z)
+        
+    else:
+        print("\033[91mError! Please make sure you have passed the value correctly in the \"activation\" parameter")
+    
+    assert (A.shape == (W.shape[0], A_prev.shape[1]))
+    cache = (linear_cache, activation_cache)
+
+    return A, cache
+
+def L_model_forward(X, parameters):
+    """
+    Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation
+    
+    Arguments:
+    X -- data, numpy array of shape (input size, number of examples)
+    parameters -- output of initialize_parameters_deep()
+    
+    Returns:
+    AL -- last post-activation value
+    caches -- list of caches containing:
+                every cache of linear_relu_forward() (there are L-1 of them, indexed from 0 to L-2)
+                the cache of linear_sigmoid_forward() (there is one, indexed L-1)
+    """
+
+    caches = []
+    A = X
+    L = len(parameters) // 2                  # number of layers in the neural network
+    
+    # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list.
+    for l in range(1, L):
+        A_prev = A 
+        A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], activation = "relu")
+        caches.append(cache)
+    
+    # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list.
+    AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], activation = "sigmoid")
+    caches.append(cache)
+    
+    assert(AL.shape == (1,X.shape[1]))
+            
+    return AL, caches
+
+def compute_cost(AL, Y):
+    """
+    Implement the cost function defined by equation (7).
+
+    Arguments:
+    AL -- probability vector corresponding to your label predictions, shape (1, number of examples)
+    Y -- true "label" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)
+
+    Returns:
+    cost -- cross-entropy cost
+    """
+    
+    m = Y.shape[1]
+
+    # Compute loss from aL and y.
+    cost = (1./m) * (-np.dot(Y,np.log(AL).T) - np.dot(1-Y, np.log(1-AL).T))
+    
+    cost = np.squeeze(cost)      # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).
+    assert(cost.shape == ())
+    
+    return cost
+
+def linear_backward(dZ, cache):
+    """
+    Implement the linear portion of backward propagation for a single layer (layer l)
+
+    Arguments:
+    dZ -- Gradient of the cost with respect to the linear output (of current layer l)
+    cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer
+
+    Returns:
+    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
+    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
+    db -- Gradient of the cost with respect to b (current layer l), same shape as b
+    """
+    A_prev, W, b = cache
+    m = A_prev.shape[1]
+
+    dW = 1./m * np.dot(dZ,A_prev.T)
+    db = 1./m * np.sum(dZ, axis = 1, keepdims = True)
+    dA_prev = np.dot(W.T,dZ)
+    
+    assert (dA_prev.shape == A_prev.shape)
+    assert (dW.shape == W.shape)
+    assert (db.shape == b.shape)
+    
+    return dA_prev, dW, db
+
+def linear_activation_backward(dA, cache, activation):
+    """
+    Implement the backward propagation for the LINEAR->ACTIVATION layer.
+    
+    Arguments:
+    dA -- post-activation gradient for current layer l 
+    cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently
+    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"
+    
+    Returns:
+    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
+    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
+    db -- Gradient of the cost with respect to b (current layer l), same shape as b
+    """
+    linear_cache, activation_cache = cache
+    
+    if activation == "relu":
+        dZ = relu_backward(dA, activation_cache)
+        dA_prev, dW, db = linear_backward(dZ, linear_cache)
+        
+    elif activation == "sigmoid":
+        dZ = sigmoid_backward(dA, activation_cache)
+        dA_prev, dW, db = linear_backward(dZ, linear_cache)
+        
+    else:
+        print("\033[91mError! Please make sure you have passed the value correctly in the \"activation\" parameter")
+    
+    return dA_prev, dW, db
+
+def L_model_backward(AL, Y, caches):
+    """
+    Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group
+    
+    Arguments:
+    AL -- probability vector, output of the forward propagation (L_model_forward())
+    Y -- true "label" vector (containing 0 if non-cat, 1 if cat)
+    caches -- list of caches containing:
+                every cache of linear_activation_forward() with "relu" (there are (L-1) or them, indexes from 0 to L-2)
+                the cache of linear_activation_forward() with "sigmoid" (there is one, index L-1)
+    
+    Returns:
+    grads -- A dictionary with the gradients
+             grads["dA" + str(l)] = ... 
+             grads["dW" + str(l)] = ...
+             grads["db" + str(l)] = ... 
+    """
+    grads = {}
+    L = len(caches) # the number of layers
+    m = AL.shape[1]
+    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL
+    
+    # Initializing the backpropagation
+    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
+    
+    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "AL, Y, caches". Outputs: "grads["dAL"], grads["dWL"], grads["dbL"]
+    current_cache = caches[L-1]
+    grads["dA" + str(L-1)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, activation = "sigmoid")
+    
+    for l in reversed(range(L-1)):
+        # lth layer: (RELU -> LINEAR) gradients.
+        current_cache = caches[l]
+        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 1)], current_cache, activation = "relu")
+        grads["dA" + str(l)] = dA_prev_temp
+        grads["dW" + str(l + 1)] = dW_temp
+        grads["db" + str(l + 1)] = db_temp
+
+    return grads
+
+def update_parameters(parameters, grads, learning_rate):
+    """
+    Update parameters using gradient descent
+    
+    Arguments:
+    parameters -- python dictionary containing your parameters 
+    grads -- python dictionary containing your gradients, output of L_model_backward
+    
+    Returns:
+    parameters -- python dictionary containing your updated parameters 
+                  parameters["W" + str(l)] = ... 
+                  parameters["b" + str(l)] = ...
+    """
+    
+    L = len(parameters) // 2 # number of layers in the neural network
+
+    # Update rule for each parameter. Use a for loop.
+    for l in range(L):
+        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * grads["dW" + str(l+1)]
+        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * grads["db" + str(l+1)]
+        
+    return parameters
+
+def predict(X, y, parameters):
+    """
+    This function is used to predict the results of a  L-layer neural network.
+    
+    Arguments:
+    X -- data set of examples you would like to label
+    parameters -- parameters of the trained model
+    
+    Returns:
+    p -- predictions for the given dataset X
+    """
+    
+    m = X.shape[1]
+    n = len(parameters) // 2 # number of layers in the neural network
+    p = np.zeros((1,m))
+    
+    # Forward propagation
+    probas, caches = L_model_forward(X, parameters)
+
+    
+    # convert probas to 0/1 predictions
+    for i in range(0, probas.shape[1]):
+        if probas[0,i] > 0.5:
+            p[0,i] = 1
+        else:
+            p[0,i] = 0
+    
+    #print results
+    #print ("predictions: " + str(p))
+    #print ("true labels: " + str(y))
+    print("Accuracy: "  + str(np.sum((p == y)/m)))
+        
+    return p
+
+def print_mislabeled_images(classes, X, y, p):
+    """
+    Plots images where predictions and truth were different.
+    X -- dataset
+    y -- true labels
+    p -- predictions
+    """
+    a = p + y
+    mislabeled_indices = np.asarray(np.where(a == 1))
+    plt.rcParams['figure.figsize'] = (40.0, 40.0) # set default size of plots
+    num_images = len(mislabeled_indices[0])
+    for i in range(num_images):
+        index = mislabeled_indices[1][i]
+        
+        plt.subplot(2, num_images, i + 1)
+        plt.imshow(X[:,index].reshape(64,64,3), interpolation='nearest')
+        plt.axis('off')
+        plt.title("Prediction: " + classes[int(p[0,index])].decode("utf-8") + " \n Class: " + classes[y[0,index]].decode("utf-8"))
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/2layerNN_kiank.png b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/2layerNN_kiank.png
new file mode 100644
index 0000000..817bd2b
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/2layerNN_kiank.png differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/LlayerNN_kiank.png b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/LlayerNN_kiank.png
new file mode 100644
index 0000000..3bd56ba
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/LlayerNN_kiank.png differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/imvector.png b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/imvector.png
new file mode 100644
index 0000000..9ab91a8
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/imvector.png differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/imvectorkiank.png b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/imvectorkiank.png
new file mode 100644
index 0000000..44ada9a
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/imvectorkiank.png differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/my_image.jpg b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/my_image.jpg
new file mode 100644
index 0000000..927b359
Binary files /dev/null and b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/images/my_image.jpg differ
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/public_tests.py b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/public_tests.py
new file mode 100644
index 0000000..7b60732
--- /dev/null
+++ b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/public_tests.py	
@@ -0,0 +1,183 @@
+import numpy as np
+from test_utils import single_test, multiple_test
+
+         
+def two_layer_model_test(target):
+    np.random.seed(1)
+    n_x = 10
+    n_h = 4
+    n_y = 1
+    num_examples = 10
+    num_iterations = 2
+    layers_dims = (n_x, n_h, n_y)
+    learning_rate = 0.0075
+    X = np.random.randn(n_x, num_examples)
+    Y = np.random.randn(1, num_examples)
+    
+    expected_parameters = {'W1': np.array([[ 0.01624965, -0.00610741, -0.00528734, -0.01072836,  0.008664  ,
+                                 -0.02301103,  0.01745639, -0.00760949,  0.0031934 , -0.00248971],
+                                [ 0.01462848, -0.02057904, -0.00326745, -0.00383625,  0.01138176,
+                                 -0.01097596, -0.00171974, -0.00877601,  0.00043022,  0.00584423],
+                                [-0.01098272,  0.01148209,  0.00902102,  0.00500958,  0.00900571,
+                                 -0.00683188, -0.00123491, -0.00937164, -0.00267157,  0.00532808],
+                                [-0.00693465, -0.00400047, -0.00684685, -0.00844447, -0.00670397,
+                                 -0.00014731, -0.01113977,  0.00238846,  0.0165895 ,  0.00738212]]),
+                         'b1': np.array([[ 1.10437111e-05],
+                                [ 1.78437869e-05],
+                                [ 3.74879549e-05],
+                                [-4.42988824e-05]]),
+                         'W2': np.array([[-0.00200283, -0.00888593, -0.00751122,  0.01688162]]),
+                         'b2': np.array([[-0.00689018]])}
+    expected_costs = [np.array(0.69315968)]
+    
+    expected_output1 = (expected_parameters, expected_costs)
+    
+    expected_output2 = ({'W1': np.array([[ 0.01640028, -0.00585699, -0.00542633, -0.01069332,  0.0089055 ,
+        -0.02290418,  0.01765388, -0.00754616,  0.00326712, -0.00239159],
+       [ 0.01476737, -0.02014461, -0.0040947 , -0.0037457 ,  0.01221714,
+        -0.01054049, -0.00164111, -0.00872507,  0.00058592,  0.00615077],
+       [-0.01051621,  0.01216499,  0.009119  ,  0.0047126 ,  0.00894761,
+        -0.00672568, -0.00134921, -0.0096428 , -0.00253223,  0.00580758],
+       [-0.00728552, -0.00461461, -0.00638113, -0.00831084, -0.00654136,
+        -0.00053186, -0.01052771,  0.00320719,  0.01643914,  0.00667123]]), 
+       'b1': np.array([[ 0.00027478],
+       [ 0.00034477],
+       [ 0.00076016],
+       [-0.00084497]]), 
+       'W2': np.array([[-0.00358725, -0.00911995, -0.00831979,  0.01615845]]), 
+       'b2': np.array([[-0.13451354]])}, [np.array(0.69315968)])
+    
+    test_cases = [
+        {
+            "name":"datatype_check",
+            "input": [X, Y, layers_dims, learning_rate, num_iterations],
+            "expected": expected_output1,
+            "error":"Datatype mismatch."
+        },
+        {
+            "name": "shape_check",
+            "input": [X, Y, layers_dims, learning_rate, num_iterations],
+            "expected": expected_output1,
+            "error": "Wrong shape"
+        },
+        {
+            "name": "equation_output_check",
+            "input": [X, Y, layers_dims, learning_rate, num_iterations],
+            "expected": expected_output1,
+            "error": "Wrong output"
+        },
+        {
+            "name": "equation_output_check",
+            "input": [X, Y, layers_dims, 0.1, 3],
+            "expected": expected_output2,
+            "error": "Wrong output"
+        }
+    ]
+    
+    multiple_test(test_cases, target)
+    
+            
+        
+def L_layer_model_test(target):
+    np.random.seed(1)
+    n_x = 10 
+    n_y = 1
+    num_examples = 10
+    num_iterations = 2
+    layers_dims = (n_x, 5, 6 , n_y)
+    learning_rate = 0.0075
+    X = np.random.randn(n_x, num_examples)
+    Y = np.array([1,1,1,1,0,0,0,1,1,0]).reshape(1,10)
+    
+    expected_parameters = {'W1': np.array([[ 0.51384638, -0.19333098, -0.16705238, -0.33923196,  0.273477  ,
+         -0.72775498,  0.55170785, -0.24077478,  0.10082452, -0.07882423],
+        [ 0.46227786, -0.65153639, -0.10192959, -0.12150984,  0.35855025,
+         -0.34787253, -0.05455001, -0.27767163,  0.01337835,  0.1843845 ],
+        [-0.34790478,  0.36200264,  0.28511245,  0.15868454,  0.284931  ,
+         -0.21645471, -0.03877896, -0.29584578, -0.08480802,  0.16760667],
+        [-0.21835973, -0.12531366, -0.21720823, -0.26764975, -0.21214946,
+         -0.00438229, -0.35316347,  0.07432144,  0.52474685,  0.23453653],
+        [-0.06060968, -0.28061463, -0.23624839,  0.53526844,  0.01597194,
+         -0.20136496,  0.06021639,  0.66414167,  0.03804666,  0.19528599]]),
+ 'b1': np.array([[-2.16491028e-04],
+        [ 1.50999130e-04],
+        [ 8.71516045e-06],
+        [ 5.57557615e-05],
+        [-2.90746349e-05]]),
+ 'W2': np.array([[ 0.13428358, -0.15747685, -0.51095667, -0.15624083, -0.09342034],
+        [ 0.26226685,  0.3751336 ,  0.41644174,  0.12779375,  0.39573817],
+        [-0.33726917,  0.56041154,  0.22939257, -0.1333337 ,  0.21851314],
+        [-0.03377599,  0.50617255,  0.67960046,  0.97726521, -0.62458844],
+        [-0.64581803, -0.22559264,  0.0715349 ,  0.39173682,  0.14112904],
+        [-0.9043503 , -0.13693179,  0.37026002,  0.10284282,  0.34076545]]),
+ 'b2': np.array([[ 1.80215514e-07],
+        [-1.07935097e-04],
+        [ 1.63081605e-04],
+        [-3.51202008e-05],
+        [-7.40012619e-05],
+        [-4.43814901e-05]]),
+ 'W3': np.array([[-0.09079199, -0.08117381,  0.07667568,  0.16665535,  0.08029575,
+          0.04805811]]),
+ 'b3': np.array([[0.0013201]])}
+    expected_costs = [np.array(0.70723944)]
+    
+    expected_output1 = (expected_parameters, expected_costs)
+    expected_output2 = ({'W1': np.array([[ 0.51439065, -0.19296367, -0.16714033, -0.33902173,  0.27291558,
+                -0.72759069,  0.55155832, -0.24095201,  0.10063293, -0.07872596],
+               [ 0.46203186, -0.65172685, -0.10184775, -0.12169458,  0.35861847,
+                -0.34804029, -0.05461748, -0.27787524,  0.01346693,  0.18463095],
+               [-0.34748255,  0.36202977,  0.28512463,  0.1580327 ,  0.28509518,
+                -0.21717447, -0.03853304, -0.29563725, -0.08509025,  0.16728901],
+               [-0.21727997, -0.12486465, -0.21692552, -0.26875722, -0.21180188,
+                -0.00550575, -0.35268367,  0.07489501,  0.52436384,  0.23418418],
+               [-0.06045008, -0.28038304, -0.23617868,  0.53546925,  0.01569291,
+                -0.20115358,  0.05975429,  0.66409149,  0.03819309,  0.1956102 ]]), 
+                         'b1': np.array([[-8.61228305e-04],
+               [ 6.08187689e-04],
+               [ 3.53075377e-05],
+               [ 2.21291877e-04],
+               [-1.13591429e-04]]), 
+                         'W2': np.array([[ 0.13441428, -0.15731437, -0.51097778, -0.15627102, -0.09342034],
+               [ 0.2620349 ,  0.37492336,  0.4165605 ,  0.12801536,  0.39541677],
+               [-0.33694339,  0.56075022,  0.22940292, -0.1334017 ,  0.21863717],
+               [-0.03371679,  0.50644769,  0.67935577,  0.97680859, -0.62475679],
+               [-0.64579072, -0.22555897,  0.07142896,  0.3914475 ,  0.14104814],
+               [-0.90433399, -0.13691167,  0.37019673,  0.10266999,  0.34071712]]), 
+                         'b2': np.array([[ 1.18811550e-06],
+               [-4.25510194e-04],
+               [ 6.56178455e-04],
+               [-1.42335482e-04],
+               [-2.93618626e-04],
+               [-1.75573157e-04]]), 
+                         'W3': np.array([[-0.09087434, -0.07882982,  0.07821609,  0.16442826,  0.0783229 ,
+                 0.04648216]]), 
+                         'b3': np.array([[0.00525865]])}, [np.array(0.70723944)])
+    
+    test_cases = [
+        {
+            "name": "equation_output_check",
+            "input": [X, Y, layers_dims, learning_rate, num_iterations],
+            "expected": expected_output1,
+            "error": "Wrong output"
+        },
+        {
+            "name":"datatype_check",
+            "input": [X, Y, layers_dims, learning_rate, num_iterations],
+            "expected": expected_output1,
+            "error":"Datatype mismatch."
+        },
+        {
+            "name": "shape_check",
+            "input": [X, Y, layers_dims, learning_rate, num_iterations],
+            "expected": expected_output1,
+            "error": "Wrong shape"
+        },
+        {
+            "name": "equation_output_check",
+            "input": [X, Y, layers_dims, 0.02, 3],
+            "expected": expected_output2,
+            "error": "Wrong output"
+        },
+    ]
+    
+    multiple_test(test_cases, target)
diff --git a/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/test_utils.py b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/test_utils.py
new file mode 100644
index 0000000..d8c12d3
--- /dev/null
+++ b/Cat Image Classifier/Deep Neural Network - Cat Image Classifier/test_utils.py	
@@ -0,0 +1,143 @@
+import numpy as np
+
+def datatype_check(expected_output, target_output, error):
+    success = 0
+    if isinstance(target_output, dict):
+        for key in expected_output.keys():
+            try:
+                success += datatype_check(expected_output[key], 
+                                         target_output[key], error)
+            except:
+                print("Error: {} in variable {}. Got {} but expected type {}".format(error,
+                                                                          key, type(target_output[key]), type(expected_output[key])))
+        if success == len(target_output.keys()):
+            return 1
+        else:
+            return 0
+    elif isinstance(target_output, tuple) or isinstance(target_output, list):
+        for i in range(len(expected_output)):
+            try: 
+                success += datatype_check(expected_output[i], 
+                                         target_output[i], error)
+            except:
+                print("Error: {} in variable {}. Got type: {}  but expected type {}".format(error,
+                                                                          i, type(target_output[i]), type(expected_output[i])))
+        if success == len(target_output):
+            return 1
+        else:
+            return 0
+                
+    else:
+        assert isinstance(target_output, type(expected_output))
+        return 1
+            
+def equation_output_check(expected_output, target_output, error):
+    success = 0
+    if isinstance(expected_output, dict):
+        for key in expected_output.keys():
+            try:
+                success += equation_output_check(expected_output[key], 
+                                         target_output[key], error)
+            except:
+                print("Error: {} for variable {}.".format(error,
+                                                                          key))
+        if success == len(target_output.keys()):
+            return 1
+        else:
+            return 0
+    elif isinstance(expected_output, tuple) or isinstance(expected_output, list):
+        for i in range(len(expected_output)):
+            try: 
+                success += equation_output_check(expected_output[i], 
+                                         target_output[i], error)
+            except:
+                print("Error: {} for variable {}.".format(error, i))
+        if success == len(target_output):
+            return 1
+        else:
+            return 0
+                
+    else:
+        if hasattr(expected_output, 'shape'):
+            #np.allclose(target_output, expected_output)
+            np.testing.assert_array_almost_equal(target_output, expected_output)
+        else:
+            assert target_output == expected_output
+        return 1
+    
+def shape_check(expected_output, target_output, error):
+    success = 0
+    if isinstance(expected_output, dict):
+        for key in expected_output.keys():
+            try:
+                success += shape_check(expected_output[key], 
+                                         target_output[key], error)
+            except:
+                print("Error: {} for variable {}.".format(error, key))
+        if success == len(expected_output.keys()):
+            return 1
+        else:
+            return 0
+    elif isinstance(expected_output, tuple) or isinstance(expected_output, list):
+        for i in range(len(expected_output)):
+            try: 
+                success += shape_check(expected_output[i], 
+                                         target_output[i], error)
+            except:
+                print("Error: {} for variable {}.".format(error, i))
+        if success == len(expected_output):
+            return 1
+        else:
+            return 0
+                
+    else:
+        if hasattr(expected_output, 'shape'):
+            assert target_output.shape == expected_output.shape
+        return 1
+                
+def single_test(test_cases, target):
+    success = 0
+    for test_case in test_cases:
+        try:
+            if test_case['name'] == "datatype_check":
+                assert isinstance(target(*test_case['input']),
+                                  type(test_case["expected"]))
+                success += 1
+            if test_case['name'] == "equation_output_check":
+                assert np.allclose(test_case["expected"],
+                                   target(*test_case['input']))
+                success += 1
+            if test_case['name'] == "shape_check":
+                assert test_case['expected'].shape == target(*test_case['input']).shape
+                success += 1
+        except:
+            print("Error: " + test_case['error'])
+            
+    if success == len(test_cases):
+        print("\033[92m All tests passed.")
+    else:
+        print('\033[92m', success," Tests passed")
+        print('\033[91m', len(test_cases) - success, " Tests failed")
+        raise AssertionError("Not all tests were passed for {}. Check your equations and avoid using global variables inside the function.".format(target.__name__))
+        
+def multiple_test(test_cases, target):
+    success = 0
+    for test_case in test_cases:
+        try:
+            target_answer = target(*test_case['input'])                   
+            if test_case['name'] == "datatype_check":
+                success += datatype_check(test_case['expected'], target_answer, test_case['error'])
+            if test_case['name'] == "equation_output_check":
+                success += equation_output_check(test_case['expected'], target_answer, test_case['error'])
+            if test_case['name'] == "shape_check":
+                success += shape_check(test_case['expected'], target_answer, test_case['error'])
+        except:
+            print("Error: " + test_case['error'])
+            
+    if success == len(test_cases):
+        print("\033[92m All tests passed.")
+    else:
+        print('\033[92m', success," Tests passed")
+        print('\033[91m', len(test_cases) - success, " Tests failed")
+        raise AssertionError("Not all tests were passed for {}. Check your equations and avoid using global variables inside the function.".format(target.__name__))
+        
\ No newline at end of file
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/Logistic Regression - Cat Image Classifier.ipynb b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/Logistic Regression - Cat Image Classifier.ipynb
new file mode 100644
index 0000000..fe58b53
--- /dev/null
+++ b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/Logistic Regression - Cat Image Classifier.ipynb	
@@ -0,0 +1,1535 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Logistic Regression - Cat Image Classifier\n",
+    "\n",
+    "Welcome to Logistic Regression - Cat Image Classifier You will build a logistic regression classifier to recognize cats. This project will step you through how to do this with a Neural Network mindset, and will also hone your intuitions about deep learning.\n",
+    "\n",
+    "**Instructions:**\n",
+    "- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.\n",
+    "- Use `np.dot(X,Y)` to calculate dot products.\n",
+    "\n",
+    "**You will learn to:**\n",
+    "- Build the general architecture of a learning algorithm, including:\n",
+    "    - Initializing parameters\n",
+    "    - Calculating the cost function and its gradient\n",
+    "    - Using an optimization algorithm (gradient descent) \n",
+    "- Gather all three functions above into a main model function, in the right order."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table of Contents\n",
+    "- [1 - Packages](#1)\n",
+    "- [2 - Overview of the Problem set](#2)\n",
+    "    - [Exercise 1](#ex-1)\n",
+    "    - [Exercise 2](#ex-2)\n",
+    "- [3 - General Architecture of the learning algorithm](#3)\n",
+    "- [4 - Building the parts of our algorithm](#4)\n",
+    "    - [4.1 - Helper functions](#4-1)\n",
+    "        - [Exercise 3 - sigmoid](#ex-3)\n",
+    "    - [4.2 - Initializing parameters](#4-2)\n",
+    "        - [Exercise 4 - initialize_with_zeros](#ex-4)\n",
+    "    - [4.3 - Forward and Backward propagation](#4-3)\n",
+    "        - [Exercise 5 - propagate](#ex-5)\n",
+    "    - [4.4 - Optimization](#4-4)\n",
+    "        - [Exercise 6 - optimize](#ex-6)\n",
+    "        - [Exercise 7 - predict](#ex-7)\n",
+    "- [5 - Merge all functions into a model](#5)\n",
+    "    - [Exercise 8 - model](#ex-8)\n",
+    "- [6 - Further analysis (optional/ungraded exercise)](#6)\n",
+    "- [7 - Test with your own image (optional/ungraded exercise)](#7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='1'></a>\n",
+    "## 1 - Packages ##\n",
+    "\n",
+    "First, let's run the cell below to import all the packages that you will need during this assignment. \n",
+    "- [numpy](https://numpy.org/doc/1.20/) is the fundamental package for scientific computing with Python.\n",
+    "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n",
+    "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python.\n",
+    "- [PIL](https://pillow.readthedocs.io/en/stable/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import copy\n",
+    "import matplotlib.pyplot as plt\n",
+    "import h5py\n",
+    "import scipy\n",
+    "from PIL import Image\n",
+    "from scipy import ndimage\n",
+    "from lr_utils import load_dataset\n",
+    "from public_tests import *\n",
+    "\n",
+    "%matplotlib inline\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='2'></a>\n",
+    "## 2 - Overview of the Problem set ##\n",
+    "\n",
+    "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n",
+    "    - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n",
+    "    - a test set of m_test images labeled as cat or non-cat\n",
+    "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n",
+    "\n",
+    "You will build a simple image-recognition algorithm that can correctly classify pictures as cat or non-cat.\n",
+    "\n",
+    "Let's get more familiar with the dataset. Load the data by running the following code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loading the data (cat/non-cat)\n",
+    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We added \"_orig\" at the end of image datasets (train and test) because we are going to preprocess them. After preprocessing, we will end up with train_set_x and test_set_x (the labels train_set_y and test_set_y don't need any preprocessing).\n",
+    "\n",
+    "Each line of your train_set_x_orig and test_set_x_orig is an array representing an image. You can visualize an example by running the following code. Feel free also to change the `index` value and re-run to see other images. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = [1], it's a 'cat' picture.\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 = 25\n",
+    "plt.imshow(train_set_x_orig[index])\n",
+    "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Many software bugs in deep learning come from having matrix/vector dimensions that don't fit. If you can keep your matrix/vector dimensions straight you will go a long way toward eliminating many bugs. \n",
+    "\n",
+    "<a name='ex-1'></a>\n",
+    "### Exercise 1\n",
+    "Find the values for:\n",
+    "    - m_train (number of training examples)\n",
+    "    - m_test (number of test examples)\n",
+    "    - num_px (= height = width of a training image)\n",
+    "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "921fe679a632ec7ec9963069fa405725",
+     "grade": false,
+     "grade_id": "cell-c4e7e9c1f174eb83",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training examples: m_train = 209\n",
+      "Number of testing examples: m_test = 50\n",
+      "Height/Width of each image: num_px = 64\n",
+      "Each image is of size: (64, 64, 3)\n",
+      "train_set_x shape: (209, 64, 64, 3)\n",
+      "train_set_y shape: (1, 209)\n",
+      "test_set_x shape: (50, 64, 64, 3)\n",
+      "test_set_y shape: (1, 50)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#(≈ 3 lines of code)\n",
+    "# m_train = \n",
+    "# m_test = \n",
+    "# num_px = \n",
+    "# YOUR CODE STARTS HERE\n",
+    "\n",
+    "m_train = train_set_x_orig.shape[0]\n",
+    "m_test = test_set_x_orig.shape[0]\n",
+    "num_px = train_set_x_orig.shape[1]\n",
+    "\n",
+    "# YOUR CODE ENDS HERE\n",
+    "\n",
+    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
+    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
+    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
+    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
+    "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
+    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
+    "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
+    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output for m_train, m_test and num_px**: \n",
+    "<table style=\"width:15%\">\n",
+    "  <tr>\n",
+    "    <td> m_train </td>\n",
+    "    <td> 209 </td> \n",
+    "  </tr>\n",
+    "  \n",
+    "  <tr>\n",
+    "    <td>m_test</td>\n",
+    "    <td> 50 </td> \n",
+    "  </tr>\n",
+    "  \n",
+    "  <tr>\n",
+    "    <td>num_px</td>\n",
+    "    <td> 64 </td> \n",
+    "  </tr>\n",
+    "  \n",
+    "</table>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For convenience, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n",
+    "\n",
+    "<a name='ex-2'></a>\n",
+    "### Exercise 2\n",
+    "Reshape the training and test data sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n",
+    "\n",
+    "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n",
+    "```python\n",
+    "X_flatten = X.reshape(X.shape[0], -1).T      # X.T is the transpose of X\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "5a2aa62bdd8c01450111b758ef159aec",
+     "grade": false,
+     "grade_id": "cell-0f43921062c34e50",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train_set_x_flatten shape: (12288, 209)\n",
+      "train_set_y shape: (1, 209)\n",
+      "test_set_x_flatten shape: (12288, 50)\n",
+      "test_set_y shape: (1, 50)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Reshape the training and test examples\n",
+    "#(≈ 2 lines of code)\n",
+    "# train_set_x_flatten = ...\n",
+    "# test_set_x_flatten = ...\n",
+    "# YOUR CODE STARTS HERE\n",
+    "\n",
+    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T\n",
+    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
+    "\n",
+    "# YOUR CODE ENDS HERE\n",
+    "\n",
+    "# Check that the first 10 pixels of the second image are in the correct place\n",
+    "assert np.alltrue(train_set_x_flatten[0:10, 1] == [196, 192, 190, 193, 186, 182, 188, 179, 174, 213]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n",
+    "assert np.alltrue(test_set_x_flatten[0:10, 1] == [115, 110, 111, 137, 129, 129, 155, 146, 145, 159]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n",
+    "\n",
+    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
+    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
+    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
+    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected Output**: \n",
+    "\n",
+    "<table style=\"width:35%\">\n",
+    "  <tr>\n",
+    "    <td>train_set_x_flatten shape</td>\n",
+    "    <td> (12288, 209)</td> \n",
+    "  </tr>\n",
+    "  <tr>\n",
+    "    <td>train_set_y shape</td>\n",
+    "    <td>(1, 209)</td> \n",
+    "  </tr>\n",
+    "  <tr>\n",
+    "    <td>test_set_x_flatten shape</td>\n",
+    "    <td>(12288, 50)</td> \n",
+    "  </tr>\n",
+    "  <tr>\n",
+    "    <td>test_set_y shape</td>\n",
+    "    <td>(1, 50)</td> \n",
+    "  </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To represent color images, the red, green and blue channels (RGB) must be specified for each pixel, and so the pixel value is actually a vector of three numbers ranging from 0 to 255.\n",
+    "\n",
+    "One common preprocessing step in machine learning is to center and standardize your dataset, meaning that you substract the mean of the whole numpy array from each example, and then divide each example by the standard deviation of the whole numpy array. But for picture datasets, it is simpler and more convenient and works almost as well to just divide every row of the dataset by 255 (the maximum value of a pixel channel).\n",
+    "\n",
+    "<!-- During the training of your model, you're going to multiply weights and add biases to some initial inputs in order to observe neuron activations. Then you backpropogate with the gradients to train the model. But, it is extremely important for each feature to have a similar range such that our gradients don't explode. You will see that more in detail later in the lectures. !--> \n",
+    "\n",
+    "Let's standardize our dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_set_x = train_set_x_flatten / 255.\n",
+    "test_set_x = test_set_x_flatten / 255."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<font color='blue'>\n",
+    "    \n",
+    "    \n",
+    "**What you need to remember:**\n",
+    "\n",
+    "Common steps for pre-processing a new dataset are:\n",
+    "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n",
+    "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n",
+    "- \"Standardize\" the data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='3'></a>\n",
+    "## 3 - General Architecture of the learning algorithm ##\n",
+    "\n",
+    "It's time to design a simple algorithm to distinguish cat images from non-cat images.\n",
+    "\n",
+    "You will build a Logistic Regression, using a Neural Network mindset. The following Figure explains why **Logistic Regression is actually a very simple Neural Network!**\n",
+    "\n",
+    "<img src=\"images/LogReg_kiank.png\" style=\"width:650px;height:400px;\">\n",
+    "\n",
+    "**Mathematical expression of the algorithm**:\n",
+    "\n",
+    "For one example $x^{(i)}$:\n",
+    "$$z^{(i)} = w^T x^{(i)} + b \\tag{1}$$\n",
+    "$$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\\tag{2}$$ \n",
+    "$$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})\\tag{3}$$\n",
+    "\n",
+    "The cost is then computed by summing over all training examples:\n",
+    "$$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})\\tag{6}$$\n",
+    "\n",
+    "**Key steps**:\n",
+    "In this exercise, you will carry out the following steps: \n",
+    "    - Initialize the parameters of the model\n",
+    "    - Learn the parameters for the model by minimizing the cost  \n",
+    "    - Use the learned parameters to make predictions (on the test set)\n",
+    "    - Analyse the results and conclude"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='4'></a>\n",
+    "## 4 - Building the parts of our algorithm ## \n",
+    "\n",
+    "The main steps for building a Neural Network are:\n",
+    "1. Define the model structure (such as number of input features) \n",
+    "2. Initialize the model's parameters\n",
+    "3. Loop:\n",
+    "    - Calculate current loss (forward propagation)\n",
+    "    - Calculate current gradient (backward propagation)\n",
+    "    - Update parameters (gradient descent)\n",
+    "\n",
+    "You often build 1-3 separately and integrate them into one function we call `model()`.\n",
+    "\n",
+    "<a name='4-1'></a>\n",
+    "### 4.1 - Helper functions\n",
+    "\n",
+    "<a name='ex-3'></a>\n",
+    "### Exercise 3 - sigmoid\n",
+    "Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid(z) = \\frac{1}{1 + e^{-z}}$ for $z = w^T x + b$ to make predictions. Use np.exp()."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "239ab1cf1028b721fd14f31b8103c40d",
+     "grade": false,
+     "grade_id": "cell-520521c430352f3b",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: sigmoid\n",
+    "\n",
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Compute the sigmoid of z\n",
+    "\n",
+    "    Arguments:\n",
+    "    z -- A scalar or numpy array of any size.\n",
+    "\n",
+    "    Return:\n",
+    "    s -- sigmoid(z)\n",
+    "    \"\"\"\n",
+    "\n",
+    "    #(≈ 1 line of code)\n",
+    "    # s = ...\n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    s = 1 / (1 + np.exp(-z))\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "    return s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "0483e6820669111a9c5914d8b24bc315",
+     "grade": true,
+     "grade_id": "cell-30ea3151cab9c491",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sigmoid([0, 2]) = [0.5        0.88079708]\n",
+      "\u001b[92mAll tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))\n",
+    "\n",
+    "sigmoid_test(sigmoid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.62245933 0.5        0.88079708]\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = np.array([0.5, 0, 2.0])\n",
+    "output = sigmoid(x)\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='4-2'></a>\n",
+    "### 4.2 - Initializing parameters\n",
+    "\n",
+    "<a name='ex-4'></a>\n",
+    "### Exercise 4 - initialize_with_zeros\n",
+    "Implement parameter initialization in the cell below. You have to initialize w as a vector of zeros. If you don't know what numpy function to use, look up np.zeros() in the Numpy library's documentation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "c4a37e375a85ddab7274a33abf46bb7c",
+     "grade": false,
+     "grade_id": "cell-befa9335e479864e",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: initialize_with_zeros\n",
+    "\n",
+    "def initialize_with_zeros(dim):\n",
+    "    \"\"\"\n",
+    "    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
+    "    \n",
+    "    Argument:\n",
+    "    dim -- size of the w vector we want (or number of parameters in this case)\n",
+    "    \n",
+    "    Returns:\n",
+    "    w -- initialized vector of shape (dim, 1)\n",
+    "    b -- initialized scalar (corresponds to the bias) of type float\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # (≈ 2 lines of code)\n",
+    "    # w = ...\n",
+    "    # b = ...\n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    w = np.zeros((dim, 1))\n",
+    "    b = 0.0\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "\n",
+    "    return w, b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "a4c13b0eafa46ca94de21b41faea8c58",
+     "grade": true,
+     "grade_id": "cell-a3b6699f145f3a3f",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "w = [[0.]\n",
+      " [0.]]\n",
+      "b = 0.0\n",
+      "\u001b[92mFirst test passed!\n",
+      "\u001b[92mSecond test passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "dim = 2\n",
+    "w, b = initialize_with_zeros(dim)\n",
+    "\n",
+    "assert type(b) == float\n",
+    "print (\"w = \" + str(w))\n",
+    "print (\"b = \" + str(b))\n",
+    "\n",
+    "initialize_with_zeros_test_1(initialize_with_zeros)\n",
+    "initialize_with_zeros_test_2(initialize_with_zeros)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='4-3'></a>\n",
+    "### 4.3 - Forward and Backward propagation\n",
+    "\n",
+    "Now that your parameters are initialized, you can do the \"forward\" and \"backward\" propagation steps for learning the parameters.\n",
+    "\n",
+    "<a name='ex-5'></a>\n",
+    "### Exercise 5 - propagate\n",
+    "Implement a function `propagate()` that computes the cost function and its gradient.\n",
+    "\n",
+    "**Hints**:\n",
+    "\n",
+    "Forward Propagation:\n",
+    "- You get X\n",
+    "- You compute $A = \\sigma(w^T X + b) = (a^{(1)}, a^{(2)}, ..., a^{(m-1)}, a^{(m)})$\n",
+    "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}(y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)}))$\n",
+    "\n",
+    "Here are the two formulas you will be using: \n",
+    "\n",
+    "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n",
+    "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "2ff9081e51809aef5e93bc1c21dc9b7b",
+     "grade": false,
+     "grade_id": "cell-11af17e28077b3d3",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: propagate\n",
+    "\n",
+    "def propagate(w, b, X, Y):\n",
+    "    \"\"\"\n",
+    "    Implement the cost function and its gradient for the propagation explained above\n",
+    "\n",
+    "    Arguments:\n",
+    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
+    "    b -- bias, a scalar\n",
+    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
+    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
+    "\n",
+    "    Return:\n",
+    "    cost -- negative log-likelihood cost for logistic regression\n",
+    "    dw -- gradient of the loss with respect to w, thus same shape as w\n",
+    "    db -- gradient of the loss with respect to b, thus same shape as b\n",
+    "    \n",
+    "    Tips:\n",
+    "    - Write your code step by step for the propagation. np.log(), np.dot()\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    m = X.shape[1]\n",
+    "    \n",
+    "    # FORWARD PROPAGATION (FROM X TO COST)\n",
+    "    #(≈ 2 lines of code)\n",
+    "    # compute activation\n",
+    "    # A = ...\n",
+    "    # compute cost by using np.dot to perform multiplication. \n",
+    "    # And don't use loops for the sum.\n",
+    "    # cost = ...                                \n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    A = sigmoid(np.dot(w.T, X) + b)\n",
+    "    \n",
+    "    cost = (-1 / m) * np.sum((Y * np.log(A) + (1 - Y) * np.log(1-A)))\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "\n",
+    "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
+    "    #(≈ 2 lines of code)\n",
+    "    # dw = ...\n",
+    "    # db = ...\n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    dw = np.dot(X, (A-Y).T) / m\n",
+    "    \n",
+    "    db = np.sum(A-Y) / m\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "    cost = np.squeeze(np.array(cost))\n",
+    "\n",
+    "    \n",
+    "    grads = {\"dw\": dw,\n",
+    "             \"db\": db}\n",
+    "    \n",
+    "    return grads, cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "b8a1a4b1ff8d70ac609d721490b4d826",
+     "grade": true,
+     "grade_id": "cell-d1594d75b61dd554",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dw = [[ 0.25071532]\n",
+      " [-0.06604096]]\n",
+      "db = -0.12500404500439652\n",
+      "cost = 0.15900537707692405\n",
+      "\u001b[92mAll tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "w =  np.array([[1.], [2]])\n",
+    "b = 1.5\n",
+    "X = np.array([[1., -2., -1.], [3., 0.5, -3.2]])\n",
+    "Y = np.array([[1, 1, 0]])\n",
+    "grads, cost = propagate(w, b, X, Y)\n",
+    "\n",
+    "assert type(grads[\"dw\"]) == np.ndarray\n",
+    "assert grads[\"dw\"].shape == (2, 1)\n",
+    "assert type(grads[\"db\"]) == np.float64\n",
+    "\n",
+    "\n",
+    "print (\"dw = \" + str(grads[\"dw\"]))\n",
+    "print (\"db = \" + str(grads[\"db\"]))\n",
+    "print (\"cost = \" + str(cost))\n",
+    "\n",
+    "propagate_test(propagate)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Expected output**\n",
+    "\n",
+    "```\n",
+    "dw = [[ 0.25071532]\n",
+    " [-0.06604096]]\n",
+    "db = -0.1250040450043965\n",
+    "cost = 0.15900537707692405\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='4-4'></a>\n",
+    "### 4.4 - Optimization\n",
+    "- You have initialized your parameters.\n",
+    "- You are also able to compute a cost function and its gradient.\n",
+    "- Now, you want to update the parameters using gradient descent.\n",
+    "\n",
+    "<a name='ex-6'></a>\n",
+    "### Exercise 6 - optimize\n",
+    "Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "49d9b4c1a780bf141c8eb48e06cbb494",
+     "grade": false,
+     "grade_id": "cell-616d6883e807448d",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: optimize\n",
+    "\n",
+    "def optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False):\n",
+    "    \"\"\"\n",
+    "    This function optimizes w and b by running a gradient descent algorithm\n",
+    "    \n",
+    "    Arguments:\n",
+    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
+    "    b -- bias, a scalar\n",
+    "    X -- data of shape (num_px * num_px * 3, number of examples)\n",
+    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
+    "    num_iterations -- number of iterations of the optimization loop\n",
+    "    learning_rate -- learning rate of the gradient descent update rule\n",
+    "    print_cost -- True to print the loss every 100 steps\n",
+    "    \n",
+    "    Returns:\n",
+    "    params -- dictionary containing the weights w and bias b\n",
+    "    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
+    "    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
+    "    \n",
+    "    Tips:\n",
+    "    You basically need to write down two steps and iterate through them:\n",
+    "        1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
+    "        2) Update the parameters using gradient descent rule for w and b.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    w = copy.deepcopy(w)\n",
+    "    b = copy.deepcopy(b)\n",
+    "    \n",
+    "    costs = []\n",
+    "    \n",
+    "    for i in range(num_iterations):\n",
+    "        # (≈ 1 lines of code)\n",
+    "        # Cost and gradient calculation \n",
+    "        # grads, cost = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        grads, cost = propagate(w, b, X, Y)\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "        \n",
+    "        # Retrieve derivatives from grads\n",
+    "        dw = grads[\"dw\"]\n",
+    "        db = grads[\"db\"]\n",
+    "        \n",
+    "        # update rule (≈ 2 lines of code)\n",
+    "        # w = ...\n",
+    "        # b = ...\n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        w = w - learning_rate * dw\n",
+    "        b = b - learning_rate * db\n",
+    "        \n",
+    "        # YOUR CODE ENDS HERE\n",
+    "        \n",
+    "        # Record the costs\n",
+    "        if i % 100 == 0:\n",
+    "            costs.append(cost)\n",
+    "        \n",
+    "            # Print the cost every 100 training iterations\n",
+    "            if print_cost:\n",
+    "                print (\"Cost after iteration %i: %f\" %(i, cost))\n",
+    "    \n",
+    "    params = {\"w\": w,\n",
+    "              \"b\": b}\n",
+    "    \n",
+    "    grads = {\"dw\": dw,\n",
+    "             \"db\": db}\n",
+    "    \n",
+    "    return params, grads, costs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "b65a5c90f86a990614156e41f64b4678",
+     "grade": true,
+     "grade_id": "cell-8e3d43fbb82a8901",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "w = [[0.80956046]\n",
+      " [2.0508202 ]]\n",
+      "b = 1.5948713189708588\n",
+      "dw = [[ 0.17860505]\n",
+      " [-0.04840656]]\n",
+      "db = -0.08888460336847771\n",
+      "Costs = [array(0.15900538)]\n",
+      "\u001b[92mAll tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "params, grads, costs = optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False)\n",
+    "\n",
+    "print (\"w = \" + str(params[\"w\"]))\n",
+    "print (\"b = \" + str(params[\"b\"]))\n",
+    "print (\"dw = \" + str(grads[\"dw\"]))\n",
+    "print (\"db = \" + str(grads[\"db\"]))\n",
+    "print(\"Costs = \" + str(costs))\n",
+    "\n",
+    "optimize_test(optimize)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='ex-7'></a>\n",
+    "### Exercise 7 - predict\n",
+    "The previous function will output the learned w and b. We are able to use w and b to predict the labels for a dataset X. Implement the `predict()` function. There are two steps to computing predictions:\n",
+    "\n",
+    "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n",
+    "\n",
+    "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "e56419b97ebf382a8f93ac2873988887",
+     "grade": false,
+     "grade_id": "cell-d6f924f49c51dc2f",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: predict\n",
+    "\n",
+    "def predict(w, b, X):\n",
+    "    '''\n",
+    "    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
+    "    \n",
+    "    Arguments:\n",
+    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
+    "    b -- bias, a scalar\n",
+    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
+    "    \n",
+    "    Returns:\n",
+    "    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
+    "    '''\n",
+    "    \n",
+    "    m = X.shape[1]\n",
+    "    Y_prediction = np.zeros((1, m))\n",
+    "    w = w.reshape(X.shape[0], 1)\n",
+    "    \n",
+    "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
+    "    #(≈ 1 line of code)\n",
+    "    # A = ...\n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    A = sigmoid(np.dot(w.T, X) + b)\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "    for i in range(A.shape[1]):\n",
+    "        \n",
+    "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
+    "        #(≈ 4 lines of code)\n",
+    "        # if A[0, i] > ____ :\n",
+    "        #     Y_prediction[0,i] = \n",
+    "        # else:\n",
+    "        #     Y_prediction[0,i] = \n",
+    "        # YOUR CODE STARTS HERE\n",
+    "        \n",
+    "        if A[0, i] > 0.5  :\n",
+    "            Y_prediction[0,i] = 1\n",
+    "        else:\n",
+    "            Y_prediction[0,i] = 0\n",
+    "\n",
+    "        # YOUR CODE ENDS HERE\n",
+    "    \n",
+    "    return Y_prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "e3ea12608f15798d542a07c1bc9f561b",
+     "grade": true,
+     "grade_id": "cell-90b1fb967269548c",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "predictions = [[1. 1. 0.]]\n",
+      "\u001b[92mAll tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "w = np.array([[0.1124579], [0.23106775]])\n",
+    "b = -0.3\n",
+    "X = np.array([[1., -1.1, -3.2],[1.2, 2., 0.1]])\n",
+    "print (\"predictions = \" + str(predict(w, b, X)))\n",
+    "\n",
+    "predict_test(predict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<font color='blue'>\n",
+    "    \n",
+    "**What to remember:**\n",
+    "    \n",
+    "You've implemented several functions that:\n",
+    "- Initialize (w,b)\n",
+    "- Optimize the loss iteratively to learn parameters (w,b):\n",
+    "    - Computing the cost and its gradient \n",
+    "    - Updating the parameters using gradient descent\n",
+    "- Use the learned (w,b) to predict the labels for a given set of examples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='5'></a>\n",
+    "## 5 - Merge all functions into a model ##\n",
+    "\n",
+    "You will now see how the overall model is structured by putting together all the building blocks (functions implemented in the previous parts) together, in the right order.\n",
+    "\n",
+    "<a name='ex-8'></a>\n",
+    "### Exercise 8 - model\n",
+    "Implement the model function. Use the following notation:\n",
+    "    - Y_prediction_test for your predictions on the test set\n",
+    "    - Y_prediction_train for your predictions on the train set\n",
+    "    - parameters, grads, costs for the outputs of optimize()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "deletable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "f23cca6cfb750397e5d2ac44977e2c2a",
+     "grade": false,
+     "grade_id": "cell-6dcba5967c4cbf8c",
+     "locked": false,
+     "schema_version": 3,
+     "solution": true,
+     "task": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GRADED FUNCTION: model\n",
+    "\n",
+    "def model(X_train, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):\n",
+    "    \"\"\"\n",
+    "    Builds the logistic regression model by calling the function you've implemented previously\n",
+    "    \n",
+    "    Arguments:\n",
+    "    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
+    "    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
+    "    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
+    "    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
+    "    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
+    "    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
+    "    print_cost -- Set to True to print the cost every 100 iterations\n",
+    "    \n",
+    "    Returns:\n",
+    "    d -- dictionary containing information about the model.\n",
+    "    \"\"\"\n",
+    "    # (≈ 1 line of code)   \n",
+    "    # initialize parameters with zeros \n",
+    "    # w, b = ...\n",
+    "    \n",
+    "    #(≈ 1 line of code)\n",
+    "    # Gradient descent \n",
+    "    # params, grads, costs = ...\n",
+    "    \n",
+    "    # Retrieve parameters w and b from dictionary \"params\"\n",
+    "    # w = ...\n",
+    "    # b = ...\n",
+    "    \n",
+    "    # Predict test/train set examples (≈ 2 lines of code)\n",
+    "    # Y_prediction_test = ...\n",
+    "    # Y_prediction_train = ...\n",
+    "    \n",
+    "    # YOUR CODE STARTS HERE\n",
+    "    \n",
+    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
+    "    params, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
+    "    w = params[\"w\"]\n",
+    "    b = params[\"b\"]\n",
+    "    Y_prediction_test = predict(w, b, X_test)\n",
+    "    Y_prediction_train = predict(w, b, X_train)\n",
+    "    \n",
+    "    # YOUR CODE ENDS HERE\n",
+    "\n",
+    "    # Print train/test Errors\n",
+    "    if print_cost:\n",
+    "        print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
+    "        print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
+    "\n",
+    "    \n",
+    "    d = {\"costs\": costs,\n",
+    "         \"Y_prediction_test\": Y_prediction_test, \n",
+    "         \"Y_prediction_train\" : Y_prediction_train, \n",
+    "         \"w\" : w, \n",
+    "         \"b\" : b,\n",
+    "         \"learning_rate\" : learning_rate,\n",
+    "         \"num_iterations\": num_iterations}\n",
+    "    \n",
+    "    return d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "deletable": false,
+    "editable": false,
+    "nbgrader": {
+     "cell_type": "code",
+     "checksum": "b468bc5ddf6ecc5c7dbcb9a02cfe0216",
+     "grade": true,
+     "grade_id": "cell-4170e070f3cde17e",
+     "locked": true,
+     "points": 10,
+     "schema_version": 3,
+     "solution": false,
+     "task": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[92mAll tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "from public_tests import *\n",
+    "\n",
+    "model_test(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you pass all the tests, run the following cell to train your model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost after iteration 0: 0.693147\n",
+      "Cost after iteration 100: 0.584508\n",
+      "Cost after iteration 200: 0.466949\n",
+      "Cost after iteration 300: 0.376007\n",
+      "Cost after iteration 400: 0.331463\n",
+      "Cost after iteration 500: 0.303273\n",
+      "Cost after iteration 600: 0.279880\n",
+      "Cost after iteration 700: 0.260042\n",
+      "Cost after iteration 800: 0.242941\n",
+      "Cost after iteration 900: 0.228004\n",
+      "Cost after iteration 1000: 0.214820\n",
+      "Cost after iteration 1100: 0.203078\n",
+      "Cost after iteration 1200: 0.192544\n",
+      "Cost after iteration 1300: 0.183033\n",
+      "Cost after iteration 1400: 0.174399\n",
+      "Cost after iteration 1500: 0.166521\n",
+      "Cost after iteration 1600: 0.159305\n",
+      "Cost after iteration 1700: 0.152667\n",
+      "Cost after iteration 1800: 0.146542\n",
+      "Cost after iteration 1900: 0.140872\n",
+      "train accuracy: 99.04306220095694 %\n",
+      "test accuracy: 70.0 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "logistic_regression_model = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=2000, learning_rate=0.005, print_cost=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Comment**: Training accuracy is close to 100%. This is a good sanity check: your model is working and has high enough capacity to fit the training data. Test accuracy is 70%. It is actually not bad for this simple model, given the small dataset we used and that logistic regression is a linear classifier. But no worries, you'll build an even better classifier next week!\n",
+    "\n",
+    "Also, you see that the model is clearly overfitting the training data. Later in this specialization you will learn how to reduce overfitting, for example by using regularization. Using the code below (and changing the `index` variable) you can look at predictions on pictures of the test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = 1, you predicted that it is a \"cat\" picture.\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 that was wrongly classified.\n",
+    "index = 1\n",
+    "plt.imshow(test_set_x[:, index].reshape((num_px, num_px, 3)))\n",
+    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[int(logistic_regression_model['Y_prediction_test'][0,index])].decode(\"utf-8\") +  \"\\\" picture.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's also plot the cost function and the gradients."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "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": [
+    "# Plot learning curve (with costs)\n",
+    "costs = np.squeeze(logistic_regression_model['costs'])\n",
+    "plt.plot(costs)\n",
+    "plt.ylabel('cost')\n",
+    "plt.xlabel('iterations (per hundreds)')\n",
+    "plt.title(\"Learning rate =\" + str(logistic_regression_model[\"learning_rate\"]))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Interpretation**:\n",
+    "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='6'></a>\n",
+    "## 6 - Further analysis (optional/ungraded exercise) ##\n",
+    "\n",
+    "Congratulations on building your first image classification model. Let's analyze it further, and examine possible choices for the learning rate $\\alpha$. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Choice of learning rate ####\n",
+    "\n",
+    "**Reminder**:\n",
+    "In order for Gradient Descent to work you must choose the learning rate wisely. The learning rate $\\alpha$  determines how rapidly we update the parameters. If the learning rate is too large we may \"overshoot\" the optimal value. Similarly, if it is too small we will need too many iterations to converge to the best values. That's why it is crucial to use a well-tuned learning rate.\n",
+    "\n",
+    "Let's compare the learning curve of our model with several choices of learning rates. Run the cell below. This should take about 1 minute. Feel free also to try different values than the three we have initialized the `learning_rates` variable to contain, and see what happens. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training a model with learning rate: 0.01\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n",
+      "Training a model with learning rate: 0.001\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n",
+      "Training a model with learning rate: 0.0001\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\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": [
+    "learning_rates = [0.01, 0.001, 0.0001]\n",
+    "models = {}\n",
+    "\n",
+    "for lr in learning_rates:\n",
+    "    print (\"Training a model with learning rate: \" + str(lr))\n",
+    "    models[str(lr)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=1500, learning_rate=lr, print_cost=False)\n",
+    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
+    "\n",
+    "for lr in learning_rates:\n",
+    "    plt.plot(np.squeeze(models[str(lr)][\"costs\"]), label=str(models[str(lr)][\"learning_rate\"]))\n",
+    "\n",
+    "plt.ylabel('cost')\n",
+    "plt.xlabel('iterations (hundreds)')\n",
+    "\n",
+    "legend = plt.legend(loc='upper center', shadow=True)\n",
+    "frame = legend.get_frame()\n",
+    "frame.set_facecolor('0.90')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Interpretation**: \n",
+    "- Different learning rates give different costs and thus different predictions results.\n",
+    "- If the learning rate is too large (0.01), the cost may oscillate up and down. It may even diverge (though in this example, using 0.01 still eventually ends up at a good value for the cost). \n",
+    "- A lower cost doesn't mean a better model. You have to check if there is possibly overfitting. It happens when the training accuracy is a lot higher than the test accuracy.\n",
+    "- In deep learning, we usually recommend that you: \n",
+    "    - Choose the learning rate that better minimizes the cost function.\n",
+    "    - If your model overfits, use other techniques to reduce overfitting. (We'll talk about this in later videos.) \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='7'></a>\n",
+    "## 7 - Test with your own image (optional/ungraded exercise) ##\n",
+    "\n",
+    "Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:\n",
+    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
+    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
+    "    3. Change your image's name in the following code\n",
+    "    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = 0.0, your algorithm predicts a \"non-cat\" picture.\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": [
+    "# change this to the name of your image file\n",
+    "my_image = \"my_image.jpg\"   \n",
+    "\n",
+    "# We preprocess the image to fit your algorithm.\n",
+    "fname = \"images/\" + my_image\n",
+    "image = np.array(Image.open(fname).resize((num_px, num_px)))\n",
+    "plt.imshow(image)\n",
+    "image = image / 255.\n",
+    "image = image.reshape((1, num_px * num_px * 3)).T\n",
+    "my_predicted_image = predict(logistic_regression_model[\"w\"], logistic_regression_model[\"b\"], image)\n",
+    "\n",
+    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<font color='blue'>\n",
+    "    \n",
+    "**What to remember from this assignment:**\n",
+    "1. Preprocessing the dataset is important.\n",
+    "2. You implemented each function separately: initialize(), propagate(), optimize(). Then you built a model().\n",
+    "3. Tuning the learning rate (which is an example of a \"hyperparameter\") can make a big difference to the algorithm. You will see more examples of this later in this course!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, if you'd like, we invite you to try different things on this Notebook. Make sure you submit before trying anything. things you can play with include:\n",
+    "    - Play with the learning rate and the number of iterations\n",
+    "    - Try different initialization methods and compare the results\n",
+    "    - Test other preprocessings (center the data, or divide each row by its standard deviation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Bibliography:\n",
+    "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n",
+    "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/__pycache__/lr_utils.cpython-37.pyc b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/__pycache__/lr_utils.cpython-37.pyc
new file mode 100644
index 0000000..3832205
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/__pycache__/lr_utils.cpython-37.pyc differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/__pycache__/public_tests.cpython-37.pyc b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/__pycache__/public_tests.cpython-37.pyc
new file mode 100644
index 0000000..9079c94
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/__pycache__/public_tests.cpython-37.pyc differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/datasets/test_catvnoncat.h5 b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/datasets/test_catvnoncat.h5
new file mode 100644
index 0000000..f8dc438
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/datasets/test_catvnoncat.h5 differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/datasets/train_catvnoncat.h5 b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/datasets/train_catvnoncat.h5
new file mode 100644
index 0000000..5c131c6
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/datasets/train_catvnoncat.h5 differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/LogReg_kiank.png b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/LogReg_kiank.png
new file mode 100644
index 0000000..404ae5a
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/LogReg_kiank.png differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/cat_in_iran.jpg b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/cat_in_iran.jpg
new file mode 100644
index 0000000..c2aa901
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/cat_in_iran.jpg differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/gargouille.jpg b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/gargouille.jpg
new file mode 100644
index 0000000..7e6d5a8
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/gargouille.jpg differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/image1.png b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/image1.png
new file mode 100644
index 0000000..125ab80
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/image1.png differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/image2.png b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/image2.png
new file mode 100644
index 0000000..187bbc7
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/image2.png differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/la_defense.jpg b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/la_defense.jpg
new file mode 100644
index 0000000..5a28b76
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/la_defense.jpg differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/my_image.jpg b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/my_image.jpg
new file mode 100644
index 0000000..a387fc0
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/my_image.jpg differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/my_image2.jpg b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/my_image2.jpg
new file mode 100644
index 0000000..927b359
Binary files /dev/null and b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/images/my_image2.jpg differ
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/lr_utils.py b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/lr_utils.py
new file mode 100644
index 0000000..0b2d370
--- /dev/null
+++ b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/lr_utils.py	
@@ -0,0 +1,20 @@
+import numpy as np
+import h5py
+    
+    
+def load_dataset():
+    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
+    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
+    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels
+
+    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
+    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
+    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels
+
+    classes = np.array(test_dataset["list_classes"][:]) # the list of classes
+    
+    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
+    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
+    
+    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
+
diff --git a/Cat Image Classifier/Logistic Regression - Cat Image Classifier/public_tests.py b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/public_tests.py
new file mode 100644
index 0000000..1092483
--- /dev/null
+++ b/Cat Image Classifier/Logistic Regression - Cat Image Classifier/public_tests.py	
@@ -0,0 +1,146 @@
+import numpy as np
+
+         
+def sigmoid_test(target):
+    x = np.array([0, 2])
+    output = target(x)
+    assert type(output) == np.ndarray, "Wrong type. Expected np.ndarray"
+    assert np.allclose(output, [0.5, 0.88079708]), f"Wrong value. {output} != [0.5, 0.88079708]"
+    output = target(1)
+    assert np.allclose(output, 0.7310585), f"Wrong value. {output} != 0.7310585"
+    print('\033[92mAll tests passed!')
+    
+            
+        
+def initialize_with_zeros_test_1(target):
+    dim = 3
+    w, b = target(dim)
+    assert type(b) == float, f"Wrong type for b. {type(b)} != float"
+    assert b == 0., "b must be 0.0"
+    assert type(w) == np.ndarray, f"Wrong type for w. {type(w)} != np.ndarray"
+    assert w.shape == (dim, 1), f"Wrong shape for w. {w.shape} != {(dim, 1)}"
+    assert np.allclose(w, [[0.], [0.], [0.]]), f"Wrong values for w. {w} != {[[0.], [0.], [0.]]}"
+    print('\033[92mFirst test passed!')
+    
+def initialize_with_zeros_test_2(target):
+    dim = 4
+    w, b = target(dim)
+    assert type(b) == float, f"Wrong type for b. {type(b)} != float"
+    assert b == 0., "b must be 0.0"
+    assert type(w) == np.ndarray, f"Wrong type for w. {type(w)} != np.ndarray"
+    assert w.shape == (dim, 1), f"Wrong shape for w. {w.shape} != {(dim, 1)}"
+    assert np.allclose(w, [[0.], [0.], [0.], [0.]]), f"Wrong values for w. {w} != {[[0.], [0.], [0.], [0.]]}"
+    print('\033[92mSecond test passed!')    
+
+def propagate_test(target):
+    w, b = np.array([[1.], [2.], [-1]]), 2.5, 
+    X = np.array([[1., 2., -1., 0], [3., 4., -3.2, 1], [3., 4., -3.2, -3.5]])
+    Y = np.array([[1, 1, 0, 0]])
+
+    expected_dw = np.array([[-0.03909333], [ 0.12501464], [-0.99960809]])
+    expected_db = np.float64(0.288106326429569)
+    expected_grads = {'dw': expected_dw,
+                      'db': expected_db}
+    expected_cost = np.array(2.0424567983978403)
+    expected_output = (expected_grads, expected_cost)
+    
+    grads, cost = target( w, b, X, Y)
+
+    assert type(grads['dw']) == np.ndarray, f"Wrong type for grads['dw']. {type(grads['dw'])} != np.ndarray"
+    assert grads['dw'].shape == w.shape, f"Wrong shape for grads['dw']. {grads['dw'].shape} != {w.shape}"
+    assert np.allclose(grads['dw'], expected_dw), f"Wrong values for grads['dw']. {grads['dw']} != {expected_dw}"
+    assert np.allclose(grads['db'], expected_db), f"Wrong values for grads['db']. {grads['db']} != {expected_db}"
+    assert np.allclose(cost, expected_cost), f"Wrong values for cost. {cost} != {expected_cost}"
+    print('\033[92mAll tests passed!')
+
+def optimize_test(target):
+    w, b, X, Y = np.array([[1.], [2.]]), 2., np.array([[1., 2., -1.], [3., 4., -3.2]]), np.array([[1, 0, 1]])
+    expected_w = np.array([[-0.70916784], [-0.42390859]])
+    expected_b = np.float64(2.26891346)
+    expected_params = {"w": expected_w,
+                       "b": expected_b}
+   
+    expected_dw = np.array([[0.06188603], [-0.01407361]])
+    expected_db = np.float64(-0.04709353)
+    expected_grads = {"dw": expected_dw,
+                      "db": expected_db}
+    
+    expected_cost = [5.80154532, 0.31057104]
+    expected_output = (expected_params, expected_grads, expected_cost)
+    
+    params, grads, costs = target(w, b, X, Y, num_iterations=101, learning_rate=0.1, print_cost=False)
+    
+    assert type(costs) == list, "Wrong type for costs. It must be a list"
+    assert len(costs) == 2, f"Wrong length for costs. {len(costs)} != 2"
+    assert np.allclose(costs, expected_cost), f"Wrong values for costs. {costs} != {expected_cost}"
+    
+    assert type(grads['dw']) == np.ndarray, f"Wrong type for grads['dw']. {type(grads['dw'])} != np.ndarray"
+    assert grads['dw'].shape == w.shape, f"Wrong shape for grads['dw']. {grads['dw'].shape} != {w.shape}"
+    assert np.allclose(grads['dw'], expected_dw), f"Wrong values for grads['dw']. {grads['dw']} != {expected_dw}"
+    
+    assert np.allclose(grads['db'], expected_db), f"Wrong values for grads['db']. {grads['db']} != {expected_db}"
+    
+    assert type(params['w']) == np.ndarray, f"Wrong type for params['w']. {type(params['w'])} != np.ndarray"
+    assert params['w'].shape == w.shape, f"Wrong shape for params['w']. {params['w'].shape} != {w.shape}"
+    assert np.allclose(params['w'], expected_w), f"Wrong values for params['w']. {params['w']} != {expected_w}"
+    
+    assert np.allclose(params['b'], expected_b), f"Wrong values for params['b']. {params['b']} != {expected_b}"
+
+    
+    print('\033[92mAll tests passed!')   
+        
+def predict_test(target):
+    w = np.array([[0.3], [0.5], [-0.2]])
+    b = -0.33333
+    X = np.array([[1., -0.3, 1.5],[2, 0, 1], [0, -1.5, 2]])
+    
+    pred = target(w, b, X)
+    
+    assert type(pred) == np.ndarray, f"Wrong type for pred. {type(pred)} != np.ndarray"
+    assert pred.shape == (1, X.shape[1]), f"Wrong shape for pred. {pred.shape} != {(1, X.shape[1])}"
+    assert np.bitwise_not(np.allclose(pred, [[1., 1., 1]])), f"Perhaps you forget to add b in the calculation of A"
+    assert np.allclose(pred, [[1., 0., 1]]), f"Wrong values for pred. {pred} != {[[1., 0., 1.]]}"
+    
+    print('\033[92mAll tests passed!')
+    
+def model_test(target):
+    np.random.seed(0)
+    
+    expected_output = {'costs': [np.array(0.69314718)], 
+                   'Y_prediction_test': np.array([[1., 1., 0.]]), 
+                   'Y_prediction_train': np.array([[1., 1., 0., 1., 0., 0., 1.]]), 
+                   'w': np.array([[ 0.08639757],
+                           [-0.08231268],
+                           [-0.11798927],
+                           [ 0.12866053]]), 
+                   'b': -0.03983236094816321}
+    
+    # Use 3 samples for training
+    b, Y, X = 1.5, np.array([1, 0, 0, 1, 0, 0, 1]).reshape(1, 7), np.random.randn(4, 7),
+
+    # Use 6 samples for testing
+    x_test = np.random.randn(4, 3)
+    y_test = np.array([0, 1, 0])
+
+    d = target(X, Y, x_test, y_test, num_iterations=50, learning_rate=0.01)
+    
+    assert type(d['costs']) == list, f"Wrong type for d['costs']. {type(d['costs'])} != list"
+    assert len(d['costs']) == 1, f"Wrong length for d['costs']. {len(d['costs'])} != 1"
+    assert np.allclose(d['costs'], expected_output['costs']), f"Wrong values for d['costs']. {d['costs']} != {expected_output['costs']}"
+    
+    assert type(d['w']) == np.ndarray, f"Wrong type for d['w']. {type(d['w'])} != np.ndarray"
+    assert d['w'].shape == (X.shape[0], 1), f"Wrong shape for d['w']. {d['w'].shape} != {(X.shape[0], 1)}"
+    assert np.allclose(d['w'], expected_output['w']), f"Wrong values for d['w']. {d['w']} != {expected_output['w']}"
+    
+    assert np.allclose(d['b'], expected_output['b']), f"Wrong values for d['b']. {d['b']} != {expected_output['b']}"
+    
+    assert type(d['Y_prediction_test']) == np.ndarray, f"Wrong type for d['Y_prediction_test']. {type(d['Y_prediction_test'])} != np.ndarray"
+    assert d['Y_prediction_test'].shape == (1, x_test.shape[1]), f"Wrong shape for d['Y_prediction_test']. {d['Y_prediction_test'].shape} != {(1, x_test.shape[1])}"
+    assert np.allclose(d['Y_prediction_test'], expected_output['Y_prediction_test']), f"Wrong values for d['Y_prediction_test']. {d['Y_prediction_test']} != {expected_output['Y_prediction_test']}"
+    
+    assert type(d['Y_prediction_train']) == np.ndarray, f"Wrong type for d['Y_prediction_train']. {type(d['Y_prediction_train'])} != np.ndarray"
+    assert d['Y_prediction_train'].shape == (1, X.shape[1]), f"Wrong shape for d['Y_prediction_train']. {d['Y_prediction_train'].shape} != {(1, X.shape[1])}"
+    assert np.allclose(d['Y_prediction_train'], expected_output['Y_prediction_train']), f"Wrong values for d['Y_prediction_train']. {d['Y_prediction_train']} != {expected_output['Y_prediction_train']}"
+    
+    print('\033[92mAll tests passed!')
+    
diff --git a/Cat Image Classifier/README.md b/Cat Image Classifier/README.md
new file mode 100644
index 0000000..beead45
--- /dev/null
+++ b/Cat Image Classifier/README.md	
@@ -0,0 +1,27 @@
+## Cat Image Classifier
+
+### Logistic Regression
+Welcome to the Logistic Regression - Cat Image Classifier! In this project, you will learn how to build a logistic regression classifier that can recognize cats in images. You will develop your algorithm with a neural network mindset and hone your intuitions about deep learning.
+
+Instructions:
+
+- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.
+- Use np.dot(X,Y) to calculate dot products.
+
+You will learn to:
+
+- Build the general architecture of a learning algorithm, including:
+- Initializing parameters
+- Calculating the cost function and its gradient
+- Using an optimization algorithm (gradient descent)
+- Gather all three functions above into a main model function, in the right order.
+
+### Deep Neural Network
+
+By the time you complete this notebook, you will have finished the deep neural network classifier to recognize cats.
+
+To build your cat/not-a-cat classifier, you'll use the functions from the classifier to recognize cats to build a deep network. Hopefully, you'll see an improvement in accuracy over your previous logistic regression classifier implementation.
+
+After this project you will be able to:
+
+- Build and train a deep L-layer neural network and apply it to supervised learning.