05-Test set, Overfitting & Underfitting, Regularization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 05-Valid/Test set, Overfitting & Underfitting, Regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1.Train/Valid/Test dataset](#1)\n",
    "\n",
    "[2.Define Model & Training](#2)\n",
    "  - [2-1.Forward Propagation](#2-1)\n",
    "  - [2-2.Compute Loss](#2-2)\n",
    "  - [2-3.Back Propagation](#2-3)\n",
    "  - [2-4.Update Parameters](#2-4)\n",
    "  - [2-5.weight initialization](#2-5)\n",
    "  - [2-6.training](#2-6)\n",
    "\n",
    "[3.Weight Regularization](#3)\n",
    "\n",
    "[4.Dropout](#4)\n",
    "\n",
    "[5.Trainig](#5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.datasets import make_moons\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"1\"></a>\n",
    "## 1.Train/Valid/Test dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_x shape: (2, 4320)\n",
      "train_y shape: (1, 4320)\n",
      "valid_x shape: (2, 1080)\n",
      "valid_y shape: (1, 1080)\n",
      "test_x shape: (2, 600)\n",
      "test_y shape: (1, 600)\n"
     ]
    }
   ],
   "source": [
    "# 데이터셋 생성\n",
    "X, Y = make_moons(n_samples=6000, noise=0.45, random_state=42)\n",
    "\n",
    "# 데이터를 학습 및 테스트 세트로 분할\n",
    "train_x, test_x, train_y, test_y = train_test_split(X, Y, test_size=0.1, random_state=42)\n",
    "train_x, valid_x, train_y, valid_y = train_test_split(train_x, train_y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Y 레이블을 (n, 1) 형태로 변환\n",
    "train_y = train_y.reshape(-1, 1)\n",
    "valid_y = valid_y.reshape(-1, 1)\n",
    "test_y = test_y.reshape(-1, 1)\n",
    "\n",
    "# 넘파이 배열로 변환\n",
    "train_x = train_x.T\n",
    "train_y = train_y.T\n",
    "valid_x = valid_x.T\n",
    "valid_y = valid_y.T\n",
    "test_x = test_x.T\n",
    "test_y = test_y.T\n",
    "\n",
    "# 데이터 형태 확인\n",
    "print(\"train_x shape:\", train_x.shape)\n",
    "print(\"train_y shape:\", train_y.shape)\n",
    "\n",
    "print(\"valid_x shape:\", valid_x.shape)\n",
    "print(\"valid_y shape:\", valid_y.shape)\n",
    "\n",
    "print(\"test_x shape:\", test_x.shape)\n",
    "print(\"test_y shape:\", test_y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches(X, Y, mini_batch_size=64, seed=0):\n",
    "    np.random.seed(seed)\n",
    "    m = X.shape[1]\n",
    "    mini_batches = []\n",
    "\n",
    "    ## Shuffle\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_X = X[:, permutation]\n",
    "    shuffled_Y = Y[:, permutation].reshape((1, m))\n",
    "\n",
    "    num_mini_batches = math.floor(m / mini_batch_size)\n",
    "    for k in range(0, num_mini_batches):\n",
    "        mini_batch_X = shuffled_X[:, k * mini_batch_size : (k + 1) * mini_batch_size]\n",
    "        mini_batch_Y = shuffled_Y[:, k * mini_batch_size : (k + 1) * mini_batch_size]\n",
    "\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "\n",
    "    ## 마지막 미니배치의 크기가 batch_size와 다른 경우. 나머지 데이터들을 묶어서 미니 배치를 생성.\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_X = shuffled_X[:, num_mini_batches * mini_batch_size:]\n",
    "        mini_batch_Y = shuffled_Y[:, num_mini_batches * mini_batch_size:]\n",
    "\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "\n",
    "    return mini_batches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2\"></a>\n",
    "## 2.Define Model & Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2-1\"></a>\n",
    "### 2-1. Forward Propagation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Arguments:\n",
    "     - X : input data (n_x, m) n_x는 feature 수, m은 데이터 샘플 수\n",
    "     - parameters : 각 layer의 trainable params dict타입 {\"W1\", \"b1\", ..., \"WL\", \"bL\"}\n",
    "\n",
    "    Returns:\n",
    "     - AL : 출력층(L번째 layer)의 activation feature\n",
    "     - caches : 각 층의 (input, weight, bias, output)\n",
    "    \"\"\"\n",
    "    caches = []\n",
    "    A = X\n",
    "    L = len(parameters) // 2\n",
    "    \n",
    "    # [LINEAR -> RELU]*(L-1)\n",
    "    for l in range(1, L):\n",
    "        A_prev = A \n",
    "        W = parameters['W' + str(l)]\n",
    "        b = parameters['b' + str(l)]\n",
    "        Z = np.dot(W, A_prev) + b\n",
    "        A = np.maximum(0, Z)  # ReLU\n",
    "        cache = (A_prev, W, b, Z)\n",
    "        caches.append(cache)\n",
    "        \n",
    "    # LINEAR -> SIGMOID\n",
    "    WL = parameters['W' + str(L)]\n",
    "    bL = parameters['b' + str(L)]\n",
    "    ZL = np.dot(WL, A) + bL\n",
    "    AL = 1 / (1 + np.exp(-ZL))  # Sigmoid\n",
    "    cache = (A, WL, bL, ZL)\n",
    "    caches.append(cache)\n",
    "    \n",
    "    assert(AL.shape == (1, X.shape[1]))\n",
    "    \n",
    "    return AL, caches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2-2\"></a>\n",
    "### 2-2. compute_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y):\n",
    "    \"\"\"\n",
    "    Arguments:\n",
    "     - AL : label 예측에 해당하는 확률 벡터. (1, num of data samples)\n",
    "     - Y : ground-truth 벡터. (1, num of data samples)\n",
    "\n",
    "    Returns:\n",
    "     - cost : cross-entropy cost\n",
    "    \"\"\"\n",
    "    m = Y.shape[1]\n",
    "\n",
    "    # logprobs = np.multiply(np.log(AL), Y) + np.multiply((1 - Y), np.log(1 - AL))\n",
    "    logprobs = np.multiply(np.log(AL + 1e-10), Y) + np.multiply((1 - Y), np.log(1 - AL + 1e-10))\n",
    "\n",
    "    cost = -np.sum(logprobs) / m\n",
    "\n",
    "    cost = float(np.squeeze(cost))\n",
    "\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2-3\"></a>\n",
    "### 2-3.Back Propagation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu_backward(dA, Z):\n",
    "    dZ = np.array(dA, copy=True)\n",
    "    dZ[Z <= 0] = 0\n",
    "\n",
    "    return dZ\n",
    "\n",
    "def sigmoid_backward(dA, Z):\n",
    "    S = 1 / (1 + np.exp(-Z))\n",
    "    dZ = dA * S * (1-S)\n",
    "\n",
    "    return dZ\n",
    "\n",
    "def backward_propagation(X, Y, caches, AL):\n",
    "    \"\"\"\n",
    "    Backward Propagation.\n",
    "    L-1개의 [Linear -> ReLU] layer와 출력층 [Linear -> Sigmoid]의 parameter에 대한 gradient를 계산한다.\n",
    "\n",
    "    Arguments:\n",
    "     - X : 입력 데이터. (n_x, m) n_x는 feature 수, m은 데이터 샘플의 수\n",
    "     - Y : ground_truth. (1, m)\n",
    "     - caches : list 타입. 각 layer의 (input, weight, bias, output).\n",
    "     - AL : 마지막 출력층의 출력값. y hat.\n",
    "    \"\"\"\n",
    "    grads = {}\n",
    "    L = len(caches) ## layer 수\n",
    "    m = X.shape[1] ## 데이터 샘플의 수\n",
    "\n",
    "    ## cost function gradient\n",
    "    # dAL = -(np.divide(Y, AL) - np.divide(1-Y, 1-AL))\n",
    "    dAL = -(np.divide(Y, AL + 1e-10) - np.divide(1 - Y, 1 - AL + 1e-10))\n",
    "\n",
    "    ## L번째 layer(출력층) [sigmoid -> Linear] gradient\n",
    "    cache = caches[-1]\n",
    "    A_prev, WL, bL, ZL = cache\n",
    "    dZL = sigmoid_backward(dAL, ZL) ## dL/dA * dA/dZ = dL / dZ\n",
    "    dWL = np.dot(dZL, A_prev.T) ## dL/dZ * dZ/dW = dL/dW\n",
    "    dbL = np.sum(dZL, axis=1, keepdims=True) / m ## dL/dZ * dZ/db = dL/db\n",
    "    dA_prev = np.dot(WL.T, dZL) ## dL/dZ * dZ/dX = dL/dX\n",
    "\n",
    "    grads[\"dA\" + str(L)] = dA_prev\n",
    "    grads[\"dW\" + str(L)] = dWL\n",
    "    grads[\"db\" + str(L)] = dbL\n",
    "\n",
    "    for l in reversed(range(L-1)):\n",
    "        cache = caches[l]\n",
    "        A_prev, W, b, Z = cache\n",
    "        dZ = relu_backward(grads[\"dA\" + str(l + 2)], Z)\n",
    "        dW = np.dot(dZ, A_prev.T) / m\n",
    "        db = np.sum(dZ, axis=1, keepdims=True) / m\n",
    "        dA_prev = np.dot(W.T, dZ)\n",
    "\n",
    "        grads[\"dA\" + str(l + 1)] = dA_prev\n",
    "        grads[\"dW\" + str(l + 1)] = dW\n",
    "        grads[\"db\" + str(l + 1)] = db\n",
    "    \n",
    "    return grads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2-4\"></a>\n",
    "### 2-4.Update Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_parameters_with_gradient_descent(parameters, grads, learning_rate):\n",
    "    \"\"\"\n",
    "    Gradient Descent 방식으로 parameter를 업데이트.\n",
    "\n",
    "    Arguments:\n",
    "     - parameters : dict 타입. layer에 설정된 weight, bias\n",
    "     - grads : dict 타입. 각 parameter에 대한 gradients\n",
    "     - learning rate : 실수형. \n",
    "\n",
    "    Returns:\n",
    "     - parameters : dict 타입. gradient로 업데이트된 parameters\n",
    "    \"\"\"\n",
    "    L = len(parameters) // 2 ## nn을 구성하는 layer 수\n",
    "\n",
    "    for l in range(1, L + 1):\n",
    "        parameters[\"W\" + str(l)] = parameters[\"W\" + str(l)] - learning_rate * grads['dW' + str(l)]\n",
    "        parameters[\"b\" + str(l)] = parameters[\"b\" + str(l)] - learning_rate * grads['db' + str(l)]\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2-5\"></a>\n",
    "### 2-5.weight initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters_random(layers_dims):\n",
    "    \"\"\"\n",
    "    Normal Distribution을 기반으로 랜덤값을 선정.\n",
    "\n",
    "    Arguments:\n",
    "     - layer_dims : 각 layer에 설정할 unit의 수. list 타입\n",
    "    \n",
    "    Returns:\n",
    "     - parameters : 각 layer에 설정되는 weight(matrix, \"W1\", \"W2\",...\"WL\"), bias(vector, \"b1\", \"b2\",...\"bL\")의 dictionary 타입\n",
    "                    W1 : weight matrix of shape (layers_dims[1], layers_dims[0])\n",
    "                    b1 : bias vector of shape (layers_dims[1], 1)\n",
    "                    ...\n",
    "                    WL : weight matrix of shape (layers_dims[L], layers_dims[L-1])\n",
    "                    bL : bias vector of shape (layers_dims[L], 1)\n",
    "    \"\"\"\n",
    "    np.random.seed(3)\n",
    "\n",
    "    parameters = {}\n",
    "    L = len(layers_dims)\n",
    "    for l in range(1, L):\n",
    "        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * 10\n",
    "        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))\n",
    "        \n",
    "    return parameters\n",
    "\n",
    "\n",
    "def initialize_parameters_xavier(layers_dims):\n",
    "    np.random.seed(3)\n",
    "    parameters = {}\n",
    "    L = len(layers_dims) - 1\n",
    "    \n",
    "    for l in range(1, L + 1):\n",
    "        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * np.sqrt(1 / layers_dims[l-1])\n",
    "        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))\n",
    "                \n",
    "    return parameters\n",
    "\n",
    "\n",
    "def initialize_parameters_he(layers_dims):  \n",
    "    ## He Normal Distribution을 따라 확률 변수들에 확률을 부여하고, 랜덤으로 가중치 값을 선정.\n",
    "    np.random.seed(3)\n",
    "    parameters = {}\n",
    "    L = len(layers_dims) - 1\n",
    "     \n",
    "    for l in range(1, L + 1):\n",
    "        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * np.sqrt(2 / layers_dims[l-1])\n",
    "        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))\n",
    "                \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"2-6\"></a>\n",
    "### 2-6. training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X, Y, learning_rate=0.001, num_iterations=30000, print_cost=True):       \n",
    "    grads = {}\n",
    "    costs = []\n",
    "    m = X.shape[1] # number of examples\n",
    "    layers_dims = [X.shape[0], 20, 3, 1]\n",
    "    \n",
    "    parameters = initialize_parameters_he(layers_dims)\n",
    "\n",
    "    for i in range(0, num_iterations):\n",
    "        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.\n",
    "        a3, cache = forward_propagation(X, parameters)\n",
    "        \n",
    "        # Cost function\n",
    "        cost = compute_cost(a3, Y)\n",
    "            \n",
    "        # Backward propagation.\n",
    "        grads = backward_propagation(X, Y, cache, a3)\n",
    "        \n",
    "        # Update parameters.\n",
    "        parameters = update_parameters_with_gradient_descent(parameters, grads, learning_rate)\n",
    "        \n",
    "        # Print the loss every 10000 iterations\n",
    "        if print_cost and i % 10000 == 0:\n",
    "            print(\"Cost after iteration {}: {}\".format(i, cost))\n",
    "        if print_cost and i % 1000 == 0:\n",
    "            costs.append(cost)\n",
    "    \n",
    "    # plot the cost\n",
    "    plt.plot(costs)\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (x1,000)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 1.9933752227025026\n",
      "Cost after iteration 10000: 0.35806314867460776\n",
      "Cost after iteration 20000: 0.35479040231341497\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = model(train_x, train_y, learning_rate=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"3\"></a>\n",
    "## 3.Weight Regularization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost_with_regularization(A3, Y, parameters, lambd):\n",
    "    \"\"\"\n",
    "    L2 Regularization을 적용한 cost function.\n",
    "    Arguments:\n",
    "     - A3 : L번째 layer(출력층)의 출력값 (output size, number of examples)\n",
    "     - Y : ground-truth (output size, number of examples)\n",
    "     - parameters : 각 층에 적용된 trainable parameters\n",
    "    \n",
    "    Returns:\n",
    "     - cost : L2 정규화가 더해진 cost값.\n",
    "    \"\"\"\n",
    "    m = Y.shape[1]\n",
    "    W1 = parameters[\"W1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    W3 = parameters[\"W3\"]\n",
    "    \n",
    "    cross_entropy_cost = compute_cost(A3, Y)\n",
    "    L2_regularization_cost = (lambd / (2 * m)) * (np.sum(np.square(W1)) + np.sum(np.square(W2)) + np.sum(np.square(W3)))\n",
    "    \n",
    "    cost = cross_entropy_cost + L2_regularization_cost\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def backward_propagation_with_regularization(X, Y, caches, lambd):\n",
    "    \"\"\"\n",
    "    L2 regularization이 적용되었을 때의 Back propagation\n",
    "\n",
    "    Arguments:\n",
    "    - X : input dataset. (input features, number of examples)\n",
    "    - Y : ground-truth. (output size, number of examples)\n",
    "    - caches : forward propagation에서 각 layer의 (A_prev, W, b, Z)가 저장된 리스트\n",
    "    - lambd : regularization의 scaling factor\n",
    "\n",
    "    Returns:\n",
    "    - grads : 각 layer에서 발생한 gradient.\n",
    "    \"\"\"\n",
    "    grads = {}\n",
    "    L = len(caches)  # the number of layers\n",
    "    m = X.shape[1]\n",
    "    Y = Y.reshape(caches[-1][3].shape)  # after this line, Y is the same shape as AL\n",
    "\n",
    "    # Initializing the backpropagation\n",
    "    AL, current_cache = caches[-1][2], caches[-1]\n",
    "    dZL = AL - Y  # Derivative of cost with respect to AL\n",
    "    dWL = 1./m * np.dot(dZL, current_cache[0].T) + (lambd/m) * current_cache[1]\n",
    "    dbL = 1./m * np.sum(dZL, axis=1, keepdims=True)\n",
    "    dAL_prev = np.dot(current_cache[1].T, dZL)\n",
    "    \n",
    "    grads[\"dW\" + str(L)] = dWL\n",
    "    grads[\"db\" + str(L)] = dbL\n",
    "\n",
    "    # Loop from l=L-2 to l=0\n",
    "    for l in reversed(range(L-1)):\n",
    "        current_cache = caches[l]\n",
    "        dZ = np.multiply(dAL_prev, current_cache[3])\n",
    "        dW = 1./m * np.dot(dZ, current_cache[0].T) + (lambd/m) * current_cache[1]\n",
    "        db = 1./m * np.sum(dZ, axis=1, keepdims=True)\n",
    "        if l > 0:  # dA_prev is not used for the first layer\n",
    "            dAL_prev = np.dot(current_cache[1].T, dZ)\n",
    "\n",
    "        grads[\"dW\" + str(l + 1)] = dW\n",
    "        grads[\"db\" + str(l + 1)] = db\n",
    "\n",
    "    return grads\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"4\"></a>\n",
    "## 4.Dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation_with_dropout(X, parameters, keep_prob=0.5):\n",
    "    \"\"\"\n",
    "    LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID.\n",
    "    \n",
    "    Arguments:\n",
    "     - X : input dataset. (num features, number of examples)\n",
    "     - parameters : 각 layer에 적용되는 trainable parameters.\n",
    "                    W1 : weight matrix of shape (20, 2)\n",
    "                    b1 : bias vector of shape (20, 1)\n",
    "                    W2 : weight matrix of shape (3, 20)\n",
    "                    b2 : bias vector of shape (3, 1)\n",
    "                    W3 : weight matrix of shape (1, 3)\n",
    "                    b3 : bias vector of shape (1, 1)\n",
    "     - keep_prob : dropout이 적용되지 않는, 활성화되는 unit의 수(백분율)\n",
    "    \n",
    "    Returns:\n",
    "     - A3 : output layer의 출력.\n",
    "     - cache : 각 layer의 (input, weight, bias, output)\n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    \n",
    "    # retrieve parameters\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "    W3 = parameters[\"W3\"]\n",
    "    b3 = parameters[\"b3\"]\n",
    "    \n",
    "    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID\n",
    "    Z1 = np.dot(W1, X) + b1\n",
    "    A1 = np.maximum(0, Z1) ## ReLU\n",
    "\n",
    "    D1 = np.random.rand(A1.shape[0], A1.shape[1])\n",
    "    D1 = (D1 < keep_prob).astype(int)\n",
    "    A1 = np.multiply(D1, A1)\n",
    "    A1 /= keep_prob\n",
    "    \n",
    "    Z2 = np.dot(W2, A1) + b2\n",
    "    A2 = np.maximum(0, Z2) ## ReLU\n",
    "\n",
    "    D2 = np.random.rand(A2.shape[0], A2.shape[1])\n",
    "    D2 = (D2 < keep_prob).astype(int)\n",
    "    A2 = np.multiply(D2, A2)\n",
    "    A2 /= keep_prob\n",
    "    \n",
    "    \n",
    "    Z3 = np.dot(W3, A2) + b3\n",
    "    A3 = 1 / (1 + np.exp(-Z3)) ## Sigmoid    \n",
    "    cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)\n",
    "    \n",
    "    return A3, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def backward_propagation_with_dropout(X, Y, cache, keep_prob):\n",
    "    \"\"\"\n",
    "    Dropout이 적용되었을 때의 Backward propagation.\n",
    "    \n",
    "    Arguments:\n",
    "     - X : input dataset. (num features, number of examples)\n",
    "     - Y : ground-truth. (output size, number of examples)\n",
    "     - cache : forward propagation에서 각 layer의 (input, weight, bias, output)\n",
    "     - keep_prob : keep_prob : dropout이 적용되지 않는, 활성화되는 unit의 수(백분율)\n",
    "    \n",
    "    Returns:\n",
    "     - gradients : 각 layer에서 발생한 gradient.\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cache\n",
    "    \n",
    "    dZ3 = A3 - Y\n",
    "    dW3 = 1./m * np.dot(dZ3, A2.T)\n",
    "    db3 = 1./m * np.sum(dZ3, axis=1, keepdims=True)\n",
    "    dA2 = np.dot(W3.T, dZ3)\n",
    "\n",
    "    dA2 *= D2\n",
    "    dA2 /= keep_prob\n",
    "        \n",
    "    dZ2 = np.multiply(dA2, np.int64(A2 > 0))\n",
    "    dW2 = 1./m * np.dot(dZ2, A1.T)\n",
    "    db2 = 1./m * np.sum(dZ2, axis=1, keepdims=True)\n",
    "    \n",
    "    dA1 = np.dot(W2.T, dZ2)\n",
    "    dA1 *= D1\n",
    "    dA1 /= keep_prob\n",
    "    \n",
    "    \n",
    "    dZ1 = np.multiply(dA1, np.int64(A1 > 0))\n",
    "    dW1 = 1./m * np.dot(dZ1, X.T)\n",
    "    db1 = 1./m * np.sum(dZ1, axis=1, keepdims=True)\n",
    "    \n",
    "    gradients = {\"dZ3\": dZ3, \"dW3\": dW3, \"db3\": db3,\"dA2\": dA2,\n",
    "                 \"dZ2\": dZ2, \"dW2\": dW2, \"db2\": db2, \"dA1\": dA1, \n",
    "                 \"dZ1\": dZ1, \"dW1\": dW1, \"db1\": db1}\n",
    "    \n",
    "    return gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"5\"></a>\n",
    "## 5.Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X, Y, learning_rate=0.001, num_iterations=100000, print_cost=True, lambd=0, keep_prob=1):       \n",
    "    grads = {}\n",
    "    costs = []\n",
    "    m = X.shape[1] # number of examples\n",
    "    layers_dims = [X.shape[0], 4, 2, 1]\n",
    "    \n",
    "    parameters = initialize_parameters_he(layers_dims)\n",
    "\n",
    "    for i in range(0, num_iterations):\n",
    "        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.\n",
    "        if keep_prob == 1:\n",
    "            a3, cache = forward_propagation(X, parameters)\n",
    "        elif keep_prob < 1:\n",
    "            a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob)\n",
    "        \n",
    "        # Cost function\n",
    "        if lambd == 0:\n",
    "            cost = compute_cost(a3, Y)\n",
    "        else:\n",
    "            cost = compute_cost_with_regularization(a3, Y, parameters, lambd)\n",
    "            \n",
    "        assert (lambd == 0 or keep_prob == 1)\n",
    "        # Backward propagation.\n",
    "        if lambd == 0 and keep_prob == 1:\n",
    "            grads = backward_propagation(X, Y, cache)\n",
    "        elif lambd != 0:\n",
    "            grads = backward_propagation_with_regularization(X, Y, cache, lambd)\n",
    "        elif keep_prob < 1:\n",
    "            grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)\n",
    "        \n",
    "        # Update parameters.\n",
    "        parameters = update_parameters_with_gradient_descent(parameters, grads, learning_rate)\n",
    "        \n",
    "        # Print the loss every 10000 iterations\n",
    "        if print_cost and i % 10000 == 0:\n",
    "            print(\"Cost after iteration {}: {}\".format(i, cost))\n",
    "        if print_cost and i % 1000 == 0:\n",
    "            costs.append(cost)\n",
    "    \n",
    "    # plot the cost\n",
    "    plt.plot(costs)\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (x1,000)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 1.7471728477045472\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 10000: 1.1677491152153545\n",
      "Cost after iteration 20000: 0.9817028593707734\n",
      "Cost after iteration 30000: 0.8937694914687898\n",
      "Cost after iteration 40000: 0.843862447700454\n",
      "Cost after iteration 50000: 0.8118798353128428\n",
      "Cost after iteration 60000: 0.7900997592563318\n",
      "Cost after iteration 70000: 0.7748737080905029\n",
      "Cost after iteration 80000: 0.7641984133383106\n",
      "Cost after iteration 90000: 0.7566895283663235\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = model(train_x, train_y, learning_rate=0.00001, lambd=0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 1.8165254733786733\n",
      "Cost after iteration 10000: 1.4680594853517868\n",
      "Cost after iteration 20000: 1.2293373542370418\n",
      "Cost after iteration 30000: 1.0668793666937972\n",
      "Cost after iteration 40000: 0.9574814820441842\n",
      "Cost after iteration 50000: 0.8839042985550835\n",
      "Cost after iteration 60000: 0.8339668107689485\n",
      "Cost after iteration 70000: 0.7974033137121852\n",
      "Cost after iteration 80000: 0.7742982158004564\n",
      "Cost after iteration 90000: 0.7622580996492309\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = model(train_x, train_y, learning_rate=0.00001, keep_prob=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "openmmlab",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}