Convlutaional nerual network numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zero_pad(X, pad):\n",
    "    \"\"\"\n",
    "    Pad with zeros all images of the dataset X. The padding is applied to the height and width of an image, \n",
    "    as illustrated in Figure 1.\n",
    "    \n",
    "    Argument:\n",
    "    X -- python numpy array of shape (m, n_H, n_W, n_C) representing a batch of m images\n",
    "    pad -- integer, amount of padding around each image on vertical and horizontal dimensions\n",
    "    \n",
    "    Returns:\n",
    "    X_pad -- padded image of shape (m, n_H + 2*pad, n_W + 2*pad, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### (≈ 1 line)\n",
    "    X_pad = np.pad(X, ((0,0), (pad,pad), (pad,pad), (0,0)), mode='constant', constant_values = (0,0))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X_pad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x.shape =\n",
      " (4, 3, 3, 2)\n",
      "x_pad.shape =\n",
      " (4, 7, 7, 2)\n",
      "x[1,1] =\n",
      " [[ 0.90085595 -0.68372786]\n",
      " [-0.12289023 -0.93576943]\n",
      " [-0.26788808  0.53035547]]\n",
      "x_pad[1,1] =\n",
      " [[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x18f66089d48>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "x = np.random.randn(4, 3, 3, 2)\n",
    "x_pad = zero_pad(x, 2)\n",
    "print (\"x.shape =\\n\", x.shape)\n",
    "print (\"x_pad.shape =\\n\", x_pad.shape)\n",
    "print (\"x[1,1] =\\n\", x[1,1])\n",
    "print (\"x_pad[1,1] =\\n\", x_pad[1,1])\n",
    "\n",
    "fig, axarr = plt.subplots(1, 2)\n",
    "axarr[0].set_title('x')\n",
    "axarr[0].imshow(x[0,:,:,0])\n",
    "axarr[1].set_title('x_pad')\n",
    "axarr[1].imshow(x_pad[0,:,:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 0.16003707,  0.87616892],\n",
       "         [ 0.31563495, -2.02220122],\n",
       "         [-0.30620401,  0.82797464]],\n",
       "\n",
       "        [[ 0.23009474,  0.76201118],\n",
       "         [-0.22232814, -0.20075807],\n",
       "         [ 0.18656139,  0.41005165]],\n",
       "\n",
       "        [[ 0.19829972,  0.11900865],\n",
       "         [-0.67066229,  0.37756379],\n",
       "         [ 0.12182127,  1.12948391]]],\n",
       "\n",
       "\n",
       "       [[[ 1.19891788,  0.18515642],\n",
       "         [-0.37528495, -0.63873041],\n",
       "         [ 0.42349435,  0.07734007]],\n",
       "\n",
       "        [[-0.34385368,  0.04359686],\n",
       "         [-0.62000084,  0.69803203],\n",
       "         [-0.44712856,  1.2245077 ]],\n",
       "\n",
       "        [[ 0.40349164,  0.59357852],\n",
       "         [-1.09491185,  0.16938243],\n",
       "         [ 0.74055645, -0.9537006 ]]],\n",
       "\n",
       "\n",
       "       [[[-0.26621851,  0.03261455],\n",
       "         [-1.37311732,  0.31515939],\n",
       "         [ 0.84616065, -0.85951594]],\n",
       "\n",
       "        [[ 0.35054598, -1.31228341],\n",
       "         [-0.03869551, -1.61577235],\n",
       "         [ 1.12141771,  0.40890054]],\n",
       "\n",
       "        [[-0.02461696, -0.77516162],\n",
       "         [ 1.27375593,  1.96710175],\n",
       "         [-1.85798186,  1.23616403]]],\n",
       "\n",
       "\n",
       "       [[[ 1.62765075,  0.3380117 ],\n",
       "         [-1.19926803,  0.86334532],\n",
       "         [-0.1809203 , -0.60392063]],\n",
       "\n",
       "        [[-1.23005814,  0.5505375 ],\n",
       "         [ 0.79280687, -0.62353073],\n",
       "         [ 0.52057634, -1.14434139]],\n",
       "\n",
       "        [[ 0.80186103,  0.0465673 ],\n",
       "         [-0.18656977, -0.10174587],\n",
       "         [ 0.86888616,  0.75041164]]]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(4, 3, 3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_single_step(a_slice_prev, W, b):\n",
    "    \"\"\"\n",
    "    Apply one filter defined by parameters W on a single slice (a_slice_prev) of the output activation \n",
    "    of the previous layer.\n",
    "    \n",
    "    Arguments:\n",
    "    a_slice_prev -- slice of input data of shape (f, f, n_C_prev)\n",
    "    W -- Weight parameters contained in a window - matrix of shape (f, f, n_C_prev)\n",
    "    b -- Bias parameters contained in a window - matrix of shape (1, 1, 1)\n",
    "    \n",
    "    Returns:\n",
    "    Z -- a scalar value, the result of convolving the sliding window (W, b) on a slice x of the input data\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    # Element-wise product between a_slice_prev and W. Do not add the bias yet.\n",
    "    s = a_slice_prev*W\n",
    "    # Sum over all entries of the volume s.\n",
    "    Z = np.sum(s)\n",
    "    # Add bias b to Z. Cast b to a float() so that Z results in a scalar value.\n",
    "    Z +=b\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    return Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z = [[[-6.99908945]]]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "a_slice_prev = np.random.randn(4, 4, 3)\n",
    "W = np.random.randn(4, 4, 3)\n",
    "b = np.random.randn(1, 1, 1)\n",
    "\n",
    "Z = conv_single_step(a_slice_prev, W, b)\n",
    "print(\"Z =\", Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_forward(A_prev, W, b, hparameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for a convolution function\n",
    "    \n",
    "    Arguments:\n",
    "    A_prev -- output activations of the previous layer, \n",
    "        numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    W -- Weights, numpy array of shape (f, f, n_C_prev, n_C)\n",
    "    b -- Biases, numpy array of shape (1, 1, 1, n_C)\n",
    "    hparameters -- python dictionary containing \"stride\" and \"pad\"\n",
    "        \n",
    "    Returns:\n",
    "    Z -- conv output, numpy array of shape (m, n_H, n_W, n_C)\n",
    "    cache -- cache of values needed for the conv_backward() function\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # Retrieve dimensions from A_prev's shape (≈1 line)  \n",
    "    (m, n_H_prev, n_W_prev, n_C_prev) =A_prev.shape\n",
    "    \n",
    "    # Retrieve dimensions from W's shape (≈1 line)\n",
    "    (f, f, n_C_prev, n_C) = W.shape\n",
    "    \n",
    "    # Retrieve information from \"hparameters\" (≈2 lines)\n",
    "    stride = hparameters[\"stride\"]\n",
    "    pad = hparameters[\"pad\"]\n",
    "    \n",
    "    # Compute the dimensions of the CONV output volume using the formula given above. \n",
    "    # Hint: use int() to apply the 'floor' operation. (≈2 lines)\n",
    "    n_H = int((n_H_prev-f+2*pad)/stride+1)\n",
    "    n_W = int((n_W_prev-f+2*pad)/stride+1)\n",
    "    \n",
    "    # Initialize the output volume Z with zeros. (≈1 line)\n",
    "    Z = np.zeros((m, n_H, n_W, n_C))\n",
    "    \n",
    "    # Create A_prev_pad by padding A_prev\n",
    "    A_prev_pad = zero_pad(A_prev, pad)\n",
    "    \n",
    "    for i in range(m):               # loop over the batch of training examples\n",
    "        a_prev_pad = A_prev_pad[i]              # Select ith training example's padded activation\n",
    "        for h in range(n_H):           # loop over vertical axis of the output volume\n",
    "            # Find the vertical start and end of the current \"slice\" (≈2 lines)\n",
    "            vert_start = h*stride\n",
    "            vert_end = vert_start+f\n",
    "            \n",
    "            for w in range(n_W):       # loop over horizontal axis of the output volume\n",
    "                # Find the horizontal start and end of the current \"slice\" (≈2 lines)\n",
    "                horiz_start = w*stride\n",
    "                horiz_end = horiz_start+f\n",
    "                \n",
    "                for c in range(n_C):   # loop over channels (= #filters) of the output volume\n",
    "                                        \n",
    "                    # Use the corners to define the (3D) slice of a_prev_pad (See Hint above the cell). (≈1 line)\n",
    "                    a_slice_prev = a_prev_pad[vert_start:vert_end,horiz_start:horiz_end ,:]\n",
    "                    \n",
    "                    # Convolve the (3D) slice with the correct filter W and bias b, to get back one output neuron. (≈3 line)\n",
    "                    weights =W[:,:,:,c]\n",
    "                    biases =b[:,:,:,c]\n",
    "                    Z[i, h, w, c] =conv_single_step(a_slice_prev, weights, biases)\n",
    "                                        \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Making sure your output shape is correct\n",
    "    assert(Z.shape == (m, n_H, n_W, n_C))\n",
    "    \n",
    "    # Save information in \"cache\" for the backprop\n",
    "    cache = (A_prev, W, b, hparameters)\n",
    "    \n",
    "    return Z, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z's mean =\n",
      " 0.6923608807576933\n",
      "Z[3,2,1] =\n",
      " [-1.28912231  2.27650251  6.61941931  0.95527176  8.25132576  2.31329639\n",
      " 13.00689405  2.34576051]\n",
      "cache_conv[0][1][2][3] =\n",
      " [-1.1191154   1.9560789  -0.3264995  -1.34267579]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "A_prev = np.random.randn(10,5,7,4)\n",
    "W = np.random.randn(3,3,4,8)\n",
    "b = np.random.randn(1,1,1,8)\n",
    "hparameters = {\"pad\" : 1,\n",
    "               \"stride\": 2}\n",
    "\n",
    "Z, cache_conv = conv_forward(A_prev, W, b, hparameters)\n",
    "print(\"Z's mean =\\n\", np.mean(Z))\n",
    "print(\"Z[3,2,1] =\\n\", Z[3,2,1])\n",
    "print(\"cache_conv[0][1][2][3] =\\n\", cache_conv[0][1][2][3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.006894053759984"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(Z[3,2,1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pool_forward(A_prev, hparameters, mode = \"max\"):\n",
    "    \"\"\"\n",
    "    Implements the forward pass of the pooling layer\n",
    "    \n",
    "    Arguments:\n",
    "    A_prev -- Input data, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    hparameters -- python dictionary containing \"f\" and \"stride\"\n",
    "    mode -- the pooling mode you would like to use, defined as a string (\"max\" or \"average\")\n",
    "    \n",
    "    Returns:\n",
    "    A -- output of the pool layer, a numpy array of shape (m, n_H, n_W, n_C)\n",
    "    cache -- cache used in the backward pass of the pooling layer, contains the input and hparameters \n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve dimensions from the input shape\n",
    "    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape\n",
    "    \n",
    "    # Retrieve hyperparameters from \"hparameters\"\n",
    "    f = hparameters[\"f\"]\n",
    "    stride = hparameters[\"stride\"]\n",
    "    \n",
    "    # Define the dimensions of the output\n",
    "    n_H = int(1 + (n_H_prev - f) / stride)\n",
    "    n_W = int(1 + (n_W_prev - f) / stride)\n",
    "    n_C = n_C_prev\n",
    "    \n",
    "    # Initialize output matrix A\n",
    "    A = np.zeros((m, n_H, n_W, n_C))              \n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    for i in range(m):                         # loop over the training examples\n",
    "        a_prev=A_prev[i]\n",
    "        for h in range(n_H):                     # loop on the vertical axis of the output volume\n",
    "            # Find the vertical start and end of the current \"slice\" (≈2 lines)\n",
    "            vert_start = h*stride\n",
    "            vert_end = vert_start+f\n",
    "            \n",
    "            for w in range(n_W):                 # loop on the horizontal axis of the output volume\n",
    "                # Find the vertical start and end of the current \"slice\" (≈2 lines)\n",
    "                horiz_start =w*stride\n",
    "                horiz_end = horiz_start +f\n",
    "                \n",
    "                for c in range (n_C):            # loop over the channels of the output volume\n",
    "                    \n",
    "                    # Use the corners to define the current slice on the ith training example of A_prev, channel c. (≈1 line)\n",
    "                    a_prev_slice =  a_prev[vert_start:vert_end,horiz_start:horiz_end ,:]\n",
    "                    \n",
    "                    # Compute the pooling operation on the slice. \n",
    "                    # Use an if statement to differentiate the modes. \n",
    "                    # Use np.max and np.mean.\n",
    "                    if mode == \"max\":\n",
    "                        A[i, h, w, c] = np.max(a_prev_slice)\n",
    "                    elif mode == \"average\":\n",
    "                        A[i, h, w, c] = np.mean(a_prev_slice)\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Store the input and hparameters in \"cache\" for pool_backward()\n",
    "    cache = (A_prev, hparameters)\n",
    "    \n",
    "    # Making sure your output shape is correct\n",
    "    assert(A.shape == (m, n_H, n_W, n_C))\n",
    "    \n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_backward(dZ, cache):\n",
    "    \"\"\"\n",
    "    Implement the backward propagation for a convolution function\n",
    "    \n",
    "    Arguments:\n",
    "    dZ -- gradient of the cost with respect to the output of the conv layer (Z), numpy array of shape (m, n_H, n_W, n_C)\n",
    "    cache -- cache of values needed for the conv_backward(), output of conv_forward()\n",
    "    \n",
    "    Returns:\n",
    "    dA_prev -- gradient of the cost with respect to the input of the conv layer (A_prev),\n",
    "               numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    dW -- gradient of the cost with respect to the weights of the conv layer (W)\n",
    "          numpy array of shape (f, f, n_C_prev, n_C)\n",
    "    db -- gradient of the cost with respect to the biases of the conv layer (b)\n",
    "          numpy array of shape (1, 1, 1, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # Retrieve information from \"cache\"\n",
    "    (A_prev, W, b, hparameters) = cache\n",
    "    \n",
    "    # Retrieve dimensions from A_prev's shape\n",
    "    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape\n",
    "    \n",
    "    # Retrieve dimensions from W's shape\n",
    "    (f, f, n_C_prev, n_C) = W.shape\n",
    "    \n",
    "    # Retrieve information from \"hparameters\"\n",
    "    stride = hparameters[\"stride\"]\n",
    "    pad = hparameters[\"pad\"]\n",
    "    \n",
    "    # Retrieve dimensions from dZ's shape\n",
    "    (m, n_H, n_W, n_C) = dZ.shape\n",
    "    \n",
    "    # Initialize dA_prev, dW, db with the correct shapes\n",
    "    dA_prev = np.zeros(A_prev.shape)                           \n",
    "    dW =  np.zeros( W.shape)\n",
    "    db =  np.zeros((1,1,1,n_C))\n",
    "\n",
    "    # Pad A_prev and dA_prev\n",
    "    A_prev_pad = zero_pad(A_prev, pad)\n",
    "    dA_prev_pad = zero_pad(dA_prev, pad)\n",
    "    \n",
    "    for i in range(m):                       # loop over the training examples\n",
    "        \n",
    "        # select ith training example from A_prev_pad and dA_prev_pad\n",
    "        a_prev_pad = A_prev_pad[i]\n",
    "        da_prev_pad =dA_prev_pad[i]\n",
    "        \n",
    "        for h in range(n_H):                   # loop over vertical axis of the output volume\n",
    "            for w in range(n_W):               # loop over horizontal axis of the output volume\n",
    "                for c in range(n_C):           # loop over the channels of the output volume\n",
    "                    \n",
    "                    # Find the corners of the current \"slice\"\n",
    "                    vert_start = h*stride\n",
    "                    vert_end =vert_start+f\n",
    "                    horiz_start = w*stride\n",
    "                    horiz_end = horiz_start+f\n",
    "                    \n",
    "                    # Use the corners to define the slice from a_prev_pad\n",
    "                    a_slice = a_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :]\n",
    "\n",
    "                    # Update gradients for the window and the filter's parameters using the code formulas given above\n",
    "                    da_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :] +=W[:,:,:,c] * dZ[i, h, w, c]\n",
    "                    dW[:,:,:,c] +=  a_slice * dZ[i, h, w, c]\n",
    "                    db[:,:,:,c] +=  dZ[i, h, w, c]\n",
    "                    \n",
    "        # Set the ith training example's dA_prev to the unpadded da_prev_pad (Hint: use X[pad:-pad, pad:-pad, :])\n",
    "        dA_prev[i, :, :, :] = da_prev_pad[pad:-pad, pad:-pad, :]\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Making sure your output shape is correct\n",
    "    assert(dA_prev.shape == (m, n_H_prev, n_W_prev, n_C_prev))\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_mask_from_window(x):\n",
    "    \"\"\"\n",
    "    Creates a mask from an input matrix x, to identify the max entry of x.\n",
    "    \n",
    "    Arguments:\n",
    "    x -- Array of shape (f, f)\n",
    "    \n",
    "    Returns:\n",
    "    mask -- Array of the same shape as window, contains a True at the position corresponding to the max entry of x.\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### (≈1 line)\n",
    "    mask = x>=np.max(x)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dA_mean = 1.4524377775388075\n",
      "dW_mean = 1.7269914583139097\n",
      "db_mean = 7.839232564616838\n"
     ]
    }
   ],
   "source": [
    "# We'll run conv_forward to initialize the 'Z' and 'cache_conv\",\n",
    "# which we'll use to test the conv_backward function\n",
    "np.random.seed(1)\n",
    "A_prev = np.random.randn(10,4,4,3)\n",
    "W = np.random.randn(2,2,3,8)\n",
    "b = np.random.randn(1,1,1,8)\n",
    "hparameters = {\"pad\" : 2,\n",
    "               \"stride\": 2}\n",
    "Z, cache_conv = conv_forward(A_prev, W, b, hparameters)\n",
    "\n",
    "# Test conv_backward\n",
    "dA, dW, db = conv_backward(Z, cache_conv)\n",
    "print(\"dA_mean =\", np.mean(dA))\n",
    "print(\"dW_mean =\", np.mean(dW))\n",
    "print(\"db_mean =\", np.mean(db))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}