{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 數值預測的任務\n",
    "\n",
    "我們先載入這個章節範例程式碼中會使用到的第三方套件、模組或者其中的部分類別、函式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyvizml import CreateNBAData\n",
    "import requests\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 關於數值預測的任務\n",
    "\n",
    "「數值預測」是「監督式學習」的其中一種應用類型，當預測的目標向量 $y$ 屬於連續型的數值變數，那我們就能預期正在面對數值預測的任務，更廣泛被眾人知悉的名稱為「迴歸模型」。例如預測的目標向量 $y$ 是 `players` 資料中的 `weightKilograms`，在資料類別中屬於連續型的數值類別 `float`；具體來說，迴歸模型想方設法將特徵矩陣 $X$ 與目標向量 $y$ 之間的關聯以一條迴歸線（Regression Line）描繪，而描繪迴歸線所依據的截距項和係數項，就是用來逼近 $f$ 的 $h$。\n",
    "\n",
    "我們也可依 [Tom Mitchel](https://en.wikipedia.org/wiki/Tom_M._Mitchell) 對機器學習電腦程式的定義寫下數值預測的資料、任務、評估與但書，以預測 `players` 資料中的 `weightKilograms` 為例：\n",
    "\n",
    "- 資料（Experience）：一定數量的球員資料\n",
    "- 任務（Task）：利用模型預測球員的體重\n",
    "- 評估（Performance）：模型預測的體重與球員實際體重的誤差大小\n",
    "- 但書（Condition）：隨著資料觀測值筆數增加，預測誤差應該要減少"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating players df...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# players 資料中的 weightKilograms\n",
    "cnd = CreateNBAData(2019)\n",
    "players = cnd.create_players_df()\n",
    "y = players['weightKilograms'].values.astype(float)\n",
    "y.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 以 Scikit-Learn 預測器完成數值預測任務\n",
    "\n",
    "將 `heightMeters` 當作特徵矩陣為例，特徵矩陣 $X$ 與目標向量 $y$ 之間的關聯可以這樣描述。\n",
    "\n",
    "\\begin{equation}\n",
    "\\hat{y} = w_0 + w_1x_1\n",
    "\\end{equation}\n",
    "\n",
    "以 Scikit-Learn 定義好的預測器類別 `LinearRegression` 可以快速找出描繪迴歸線所依據的截距項 $w_0$ 和係數項 $w_1$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = players['heightMeters'].values.astype(float).reshape(-1, 1)\n",
    "y = players['weightKilograms'].values.astype(float)\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "h = LinearRegression()\n",
    "h.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-104.22092448587175\n",
      "[101.82540151]\n"
     ]
    }
   ],
   "source": [
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([107.57591065,  82.11956027, 100.44813254, 105.53940262,\n",
       "        95.35686246, 112.66718072,  92.30210042,  92.30210042,\n",
       "        97.39337049,  95.35686246])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 預測\n",
    "y_pred = h.predict(X_valid)\n",
    "y_pred[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "找出 $w_0$ 與 $w_1$ 就能夠描繪出一條迴歸線表達特徵矩陣 $X$ 與目標向量 $y$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 創建迴歸線的資料\n",
    "X1 = np.linspace(X.min()-0.1, X.max()+0.1).reshape(-1, 1)\n",
    "y_hat = h.predict(X1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": [
    "# 描繪迴歸線\n",
    "fig, ax = plt.subplots()\n",
    "ax.scatter(X_train.ravel(), y_train, label=\"training\")\n",
    "ax.scatter(X_valid.ravel(), y_valid, label=\"valid\")\n",
    "ax.plot(X1.ravel(), y_hat, c=\"red\", label=\"regression\")\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 Scikit-Learn 預測器的最關鍵方法呼叫是 `fit()` 方法，究竟它是如何決定 `X_train` 與 `y_train` 之間的關聯 $w$？接下來我們試圖推導並理解它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 正規方程 Normal Equation\n",
    "\n",
    "使用機器學習解決數值預測的任務，顧名思義是能夠創建出一個 $h$ 函式，這個函式可以將無標籤資料 $x$ 作為輸入，並預測目標向量 $y$ 的值作為其輸出。\n",
    "\n",
    "\\begin{align}\n",
    "\\hat{y} &= h(x; w) \\\\\n",
    "&= w_0 + w_1x_1 + ... + w_nx_n\n",
    "\\end{align}\n",
    "\n",
    "為了寫作成向量相乘形式，為 $w_0$ 補上 $x_0=1$：\n",
    "\n",
    "\\begin{align}\n",
    "\\hat{y} &= w_0x_0 + w_1x_1 + ... + w_nx_n, \\; where \\; w_0 = 1 \\\\\n",
    "&= w^Tx\n",
    "\\end{align}\n",
    "\n",
    "其中 $\\hat{y}$ 是預測值、$n$ 是特徵個數、$w$ 是係數向量；並能夠進一步延展為 `m` 筆觀測值的外觀為：\n",
    "\n",
    "\\begin{equation}\n",
    "\\hat{y} = h(X; w) = \n",
    "\\begin{bmatrix} x_{00}, x_{01}, ..., x_{0n} \\\\ x_{10}, x_{11}, ..., x_{1n} \\\\.\\\\.\\\\.\\\\ x_{m0}, x_{m1}, ..., x_{mn}\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix} w_0 \\\\ w_1 \\\\.\\\\.\\\\.\\\\ w_n \\end{bmatrix} = Xw\n",
    "\\end{equation}\n",
    "\n",
    "$h(X; w)$ 是基於 $w$ 的函式，如果第 $i$ 個特徵 $x_i$ 對應的係數 $w_i$ 為正數，該特徵與 $\\hat{y}$ 的變動同向；如果第 $i$ 個特徵 $x_i$ 對應的係數 $w_i$ 為負數，該特徵與 $\\hat{y}$ 的變動反向；如果第 $i$ 個特徵 $x_i$ 對應的係數 $w_i$ 為零，該特徵對 $\\hat{y}$ 的變動沒有影響。\n",
    "\n",
    "截至於此，資料（Experiment）與任務（Task）已經被定義妥善，特徵矩陣 $X$ 外觀 `(m, n)`、目標向量 $y$ 外觀 `(m,)`、係數向量 $w$ 外觀 `(n,)`，通過將 $X$ 輸入 $h$ 來預測 $\\hat{y}$，接下來還需要定義評估（Performance）。\n",
    "\n",
    "評估 $h$ 的方法是計算 $y^{(train)}$ 與 $\\hat{y}^{(train)}$ 之間的均方誤差（Mean squared error）：\n",
    "\n",
    "\\begin{equation}\n",
    "MSE_{train} = \\frac{1}{m}\\sum_i(y^{(train)} - \\hat{y}^{(train)})_i^2\n",
    "\\end{equation}\n",
    "\n",
    "如果寫為向量運算的外觀：\n",
    "\n",
    "\\begin{equation}\n",
    "MSE_{train} = \\frac{1}{m}\\parallel y^{(train)} - \\hat{y}^{(train)} \\parallel^2\n",
    "\\end{equation}\n",
    "\n",
    "電腦程式能夠通過觀察訓練資料藉此獲得一組能讓均方誤差最小化的係數向量 $w$，為了達成這個目的，將均方誤差表達為一個基於係數向量 $w$ 的函式 $J(w)$：\n",
    "\n",
    "\\begin{equation}\n",
    "J(w) = MSE = \\frac{1}{m} \\parallel y - Xw \\parallel^2\n",
    "\\end{equation}\n",
    "\n",
    "整理一下函式 $J(w)$ 的外觀：\n",
    "\n",
    "\\begin{align}\n",
    "J(w) &= \\frac{1}{m}(Xw - y)^T(Xw - y) \\\\\n",
    "&= \\frac{1}{m}(w^TX^T - y^T)(Xw - y) \\\\\n",
    "&= \\frac{1}{m}(w^TX^TXw - w^TX^Ty - y^TXw + y^Ty) \\\\\n",
    "&= \\frac{1}{m}(w^TX^TXw - (Xw)^Ty - y^TXw + y^Ty) \\\\\n",
    "&= \\frac{1}{m}(w^TX^TXw - 2(Xw)^Ty + y^Ty)\n",
    "\\end{align}\n",
    "\n",
    "求解 $J(w)$ 斜率為零的位置：\n",
    "\n",
    "\\begin{gather}\n",
    "\\frac{\\partial}{\\partial w} J(w) = 0 \\\\\n",
    "2X^TXw - 2X^Ty = 0 \\\\\n",
    "X^TXw = X^Ty \\\\\n",
    "w^* = (X^TX)^{-1}X^Ty\n",
    "\\end{gather}\n",
    "\n",
    "這個 $w^*$ 求解亦被稱呼為「正規方程」（Normal equation）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 自訂正規方程類別 NormalEquation\n",
    "\n",
    "我們可以依據正規方程自訂預測器類別，並與 Scikit-Learn 定義好的預測器類別 `LinearRegression` 比對係數向量是否一致。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NormalEquation:\n",
    "    \"\"\"\n",
    "    This class defines the Normal equation for linear regression.\n",
    "    Args:\n",
    "        fit_intercept (bool): Whether to add intercept for this model.\n",
    "    \"\"\"\n",
    "    def __init__(self, fit_intercept=True):\n",
    "        self._fit_intercept = fit_intercept\n",
    "    def fit(self, X_train, y_train):\n",
    "        \"\"\"\n",
    "        This function uses Normal equation to solve for weights of this model.\n",
    "        Args:\n",
    "            X_train (ndarray): 2d-array for feature matrix of training data.\n",
    "            y_train (ndarray): 1d-array for target vector of training data.\n",
    "        \"\"\"\n",
    "        self._X_train = X_train.copy()\n",
    "        self._y_train = y_train.copy()\n",
    "        m = self._X_train.shape[0]\n",
    "        if self._fit_intercept:\n",
    "            X0 = np.ones((m, 1), dtype=float)\n",
    "            self._X_train = np.concatenate([X0, self._X_train], axis=1)\n",
    "        X_train_T = np.transpose(self._X_train)\n",
    "        left_matrix = np.dot(X_train_T, self._X_train)\n",
    "        right_matrix = np.dot(X_train_T, self._y_train)\n",
    "        left_matrix_inv = np.linalg.inv(left_matrix)\n",
    "        w = np.dot(left_matrix_inv, right_matrix)\n",
    "        w_ravel = w.ravel().copy()\n",
    "        self._w = w\n",
    "        self.intercept_ = w_ravel[0]\n",
    "        self.coef_ = w_ravel[1:]\n",
    "    def predict(self, X_test):\n",
    "        \"\"\"\n",
    "        This function returns predicted values with weights of this model.\n",
    "        Args:\n",
    "            X_test (ndarray): 2d-array for feature matrix of test data.\n",
    "        \"\"\"\n",
    "        self._X_test = X_test.copy()\n",
    "        m = self._X_test.shape[0]\n",
    "        if self._fit_intercept:\n",
    "            X0 = np.ones((m, 1), dtype=float)\n",
    "            self._X_test = np.concatenate([X0, self._X_test], axis=1)\n",
    "        y_pred = np.dot(self._X_test, self._w)\n",
    "        return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = NormalEquation()\n",
    "h.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-104.22092448572948\n",
      "[101.82540151]\n"
     ]
    }
   ],
   "source": [
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([107.57591065,  82.11956027, 100.44813254, 105.53940262,\n",
       "        95.35686246, 112.66718072,  92.30210042,  92.30210042,\n",
       "        97.39337049,  95.35686246])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 預測\n",
    "y_pred = h.predict(X_valid)\n",
    "y_pred[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "比對 $w$ 與前十筆預測值可以驗證自行定義的 `NormalEquation` 類別與 Scikit-Learn 求解 $w$ 的邏輯相近。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 計算複雜性\n",
    "\n",
    "計算複雜性（Computational complexity）是電腦科學研究解決問題所需的資源，諸如時間（要通過多少步演算才能解決問題）和空間（在解決問題時需要多少記憶體），在演算法中常見到的大 O 符號就是表示演算所需時間的表達式。在正規方程中必須要透過計算 $X^TX$ 的反矩陣 $(X^TX)^{-1}$ 求解 $w^*$，這是一個外觀 `(n+1, n+1)` 的二維數值陣列（`n` 為特徵個數），計算複雜性最多是 $O(n^3)$，這意味著如果特徵個數變為 2 倍，計算 $(X^TX)^{-1}$ 的時間最多會變為 8 倍。因此當面對的特徵矩陣 `n` 很大（約莫是大於 $10^4$），正規方程的計算複雜性問題就會浮現，這時讀者可能會好奇 $n \\geq 10^4$ 會很容易遭遇嗎？在特徵矩陣是圖像時很容易遭遇，例如低解析度 $100 \\: px \\times 100 \\: px$ 的灰階圖片。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 梯度遞減 Gradient Descent\n",
    "\n",
    "另外一種在機器學習、深度學習中更為廣泛使用的演算方法稱為「梯度遞減」（Gradient descent），基本概念是先隨機初始化一組係數向量，在基於降低 $y^{(train)}$ 與 $\\hat{y}^{(train)}$ 之間誤差 $J(w)$ 之目的標之下，以迭代方式更新該組係數向量，一直到 $J(w)$ 收斂到局部最小值為止。\n",
    "\n",
    "梯度遞減的精髓在於當演算方法更新係數向量時，並不是盲目亂槍打鳥地試誤（Trial and error），而是透過「有方向性」的依據進行更新，具體來說，就是根據誤差函式 $J(w)$ 關於係數向量 $w$ 的偏微分來決定更新的方向性，而更新的幅度大小則由一個大於零、稱為「學習速率」的常數 $\\alpha$ 決定：\n",
    "\n",
    "\\begin{equation}\n",
    "w := w - \\alpha \\frac{\\partial J}{\\partial w}\n",
    "\\end{equation}\n",
    "\n",
    "讓我們用一個簡單的例子來看為什麼透過這個式子更新 $w$ 是一種「有方向性」的依據，舉例來說如果給定一組 $X^{(train)}$ 與 $y^{(train)}$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.]\n",
      " [ 1.  2.]\n",
      " [ 1.  3.]\n",
      " [ 1.  4.]\n",
      " [ 1.  5.]\n",
      " [ 1.  6.]\n",
      " [ 1.  7.]\n",
      " [ 1.  8.]\n",
      " [ 1.  9.]\n",
      " [ 1. 10.]]\n",
      "[11. 17. 23. 29. 35. 41. 47. 53. 59. 65.]\n"
     ]
    }
   ],
   "source": [
    "X0 = np.ones((10, 1))\n",
    "X1 = np.arange(1, 11).reshape(-1, 1)\n",
    "w = np.array([5, 6])\n",
    "X_train = np.concatenate([X0, X1], axis=1)\n",
    "y_train = np.dot(X_train, w)\n",
    "print(X_train)\n",
    "print(y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "從後見之明的視角來看，我們會知道係數向量 $w^*$ 的組成 $w_0=5$、$w_1=6$：\n",
    "\n",
    "\\begin{equation}\n",
    "f(x) = y = 5x_0 + 6x_1\n",
    "\\end{equation}\n",
    "\n",
    "亦即\n",
    "\n",
    "\\begin{equation}\n",
    "w^* = \\begin{bmatrix} w_0^* \\\\ w_1^* \\end{bmatrix} = \\begin{bmatrix} 5 \\\\ 6 \\end{bmatrix}\n",
    "\\end{equation}\n",
    "\n",
    "不過給定電腦程式一組 $X^{(train)}$ 與 $y^{(train)}$ 對於它來說像是拋出了一個大海撈針的問題，有無限多組的 $w$ 等著要嘗試（它甚至不知道用 $w_0$ 與 $w_1$ 就可以找到跟 $f$ 完全相同的 $h$），遑論找出 $w_0=5$、$w_1=6$；「梯度遞減」演算方法就是為電腦程式提供了一個尋找解題的方式，千里之行，始於足下，請先隨機初始化一組 $w$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.37454012, 0.95071431])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "w = np.random.rand(2)\n",
    "w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "針對這組 $w$ 可以得到一組 $\\hat{y}^{(train)}$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.32525443, 2.27596873, 3.22668304, 4.17739734, 5.12811165,\n",
       "       6.07882596, 7.02954026, 7.98025457, 8.93096888, 9.88168318])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_hat = np.dot(X_train, w)\n",
    "y_hat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "針對這組 $\\hat{y}^{(train)}$ 可以計算與 $y^{(train)}$ 的均方誤差。\n",
    "\n",
    "\\begin{equation}\n",
    "J(w) = \\frac{1}{m}\\parallel y - Xw \\parallel^2\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1259.87134315462"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = y_train.size\n",
    "j = ((y_hat - y_train).T.dot(y_hat - y_train)) / m\n",
    "j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "那麼下一次的試誤該如何更新 $w$ 才能確保離 $w^*$ 更近，讓計算出來的均方誤差會更小一些？這時梯度遞減演算方法登場，它直截了當地說：請將目前的 $w_0$ 減去學習速率 $\\alpha$ 乘上 $J(w)$ 關於 $w_0$ 的偏微分、將目前的 $w_1$ 減去學習速率 $\\alpha$ 乘上 $J(w)$ 關於 $w_1$ 的偏微分：\n",
    "\n",
    "\\begin{equation}\n",
    "w_0 := w_0 - \\alpha \\frac{\\partial J}{\\partial w_0}\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "w_1 := w_1 - \\alpha \\frac{\\partial J}{\\partial w_1}\n",
    "\\end{equation}\n",
    "\n",
    "以係數向量的外觀表示：\n",
    "\n",
    "\\begin{equation}\n",
    "w := w - \\alpha \\frac{\\partial J}{\\partial w}\n",
    "\\end{equation}\n",
    "\n",
    "接著慢慢將 $J(w)$ 關於 $w$ 的偏微分式子展開：\n",
    "\n",
    "\\begin{align}\n",
    "\\frac{\\partial J}{\\partial w} &= \\frac{1}{m}\\frac{\\partial}{\\partial w}(\\parallel y - Xw \\parallel^2) \\\\\n",
    "&= \\frac{1}{m}\\frac{\\partial}{\\partial w}(Xw - y)^T(Xw-y) \\\\\n",
    "&= \\frac{1}{m}\\frac{\\partial}{\\partial w}(w^TX^TXw - w^TX^Ty - y^TXw + y^Ty) \\\\\n",
    "&= \\frac{1}{m}\\frac{\\partial}{\\partial w}(w^TX^TXw - (Xw)^Ty - (Xw)^Ty + y^Ty) \\\\\n",
    "&= \\frac{1}{m}\\frac{\\partial}{\\partial w}(w^TX^TXw - 2(Xw)^Ty + y^Ty) \\\\\n",
    "&= \\frac{1}{m}(2X^TXw - 2X^Ty) \\\\\n",
    "&= \\frac{2}{m}(X^TXw - X^Ty) \\\\\n",
    "&= \\frac{2}{m}X^T(Xw - y) \\\\\n",
    "&= \\frac{2}{m}X^T(\\hat{y} - y)\n",
    "\\end{align}\n",
    "\n",
    "$J(w)$ 關於 $w$ 的偏微分就是演算方法中所謂的「梯度」（Gradient），在迭代過程中 $w$ 更新的方向性取決於梯度正負號，如果梯度為正，$w$ 會向左更新（減小）；如果梯度為負，$w$ 會向右更新（增大）。\n",
    "\n",
    "\\begin{equation}\n",
    "w := w - \\alpha \\frac{2}{m}X^T(\\hat{y} - y)\n",
    "\\end{equation}\n",
    "\n",
    "接著計算隨機初始化的 $w$ 其梯度為何。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -64.79306239, -439.6750571 ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradients = (2/m) * np.dot(X_train.T, y_hat - y_train)\n",
    "gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "當梯度為負，隨機初始化的 $w$ 會向右更新（增大），離後見之明視角所知的 $w_0 = 5$、$w_1 = 6$ 更加接近，在更新的方向性上是正確的。假設將學習速率設定為 0.001，更新的幅度就是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.06479306, 0.43967506])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learning_rate = 0.001\n",
    "-learning_rate * gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "經過第一次迭代更新後的 $w$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.43933318, 1.39038936])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w -= learning_rate * gradients\n",
    "w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "針對更新過一次的 $w$ 可以得到一組 $\\hat{y}^{(train)}$："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.82972254,  3.22011191,  4.61050127,  6.00089064,  7.39128   ,\n",
       "        8.78166936, 10.17205873, 11.56244809, 12.95283745, 14.34322682])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_hat = np.dot(X_train, w)\n",
    "y_hat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更新過一次的 $w$ 所對應的均方誤差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1070.1192063534622"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j = ((y_hat - y_train).T.dot(y_hat - y_train)) / m\n",
    "j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "從上述例子可以觀察到運用「梯度遞減」演算方法迭代更新係數向量的過程中，透過計算誤差函式關於係數向量的梯度決定更新的**方向性**，透過學習速率決定更新的**幅度**，在迭代進行一次之後，係數向右更新（增大）離真實的 $w^*$ 更接近了些、均方誤差也下降了些。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 自訂梯度遞減類別 GradientDescent\n",
    "\n",
    "我們可以依據梯度遞減自訂預測器類別，檢視迭代後的 $w$ 是否與後見之明視角的 $w_0 = 5$、$w_1 = 6$ 相近、均方誤差是否隨著迭代而下降。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GradientDescent:\n",
    "    \"\"\"\n",
    "    This class defines the vanilla gradient descent algorithm for linear regression.\n",
    "    Args:\n",
    "        fit_intercept (bool): Whether to add intercept for this model.\n",
    "    \"\"\"\n",
    "    def __init__(self, fit_intercept=True):\n",
    "        self._fit_intercept = fit_intercept\n",
    "    def find_gradient(self):\n",
    "        \"\"\"\n",
    "        This function returns the gradient given certain model weights.\n",
    "        \"\"\"\n",
    "        y_hat = np.dot(self._X_train, self._w)\n",
    "        gradient = (2/self._m) * np.dot(self._X_train.T, y_hat - self._y_train)\n",
    "        return gradient\n",
    "    def mean_squared_error(self):\n",
    "        \"\"\"\n",
    "        This function returns the mean squared error given certain model weights.\n",
    "        \"\"\"\n",
    "        y_hat = np.dot(self._X_train, self._w)\n",
    "        mse = ((y_hat - self._y_train).T.dot(y_hat - self._y_train)) / self._m\n",
    "        return mse\n",
    "    def fit(self, X_train, y_train, epochs=10000, learning_rate=0.001):\n",
    "        \"\"\"\n",
    "        This function uses vanilla gradient descent to solve for weights of this model.\n",
    "        Args:\n",
    "            X_train (ndarray): 2d-array for feature matrix of training data.\n",
    "            y_train (ndarray): 1d-array for target vector of training data.\n",
    "            epochs (int): The number of iterations to update the model weights.\n",
    "            learning_rate (float): The learning rate of gradient descent.\n",
    "        \"\"\"\n",
    "        self._X_train = X_train.copy()\n",
    "        self._y_train = y_train.copy()\n",
    "        self._m = self._X_train.shape[0]\n",
    "        if self._fit_intercept:\n",
    "            X0 = np.ones((self._m, 1), dtype=float)\n",
    "            self._X_train = np.concatenate([X0, self._X_train], axis=1)\n",
    "        n = self._X_train.shape[1]\n",
    "        self._w = np.random.rand(n)\n",
    "        n_prints = 10\n",
    "        print_iter = epochs // n_prints\n",
    "        w_history = dict()\n",
    "        for i in range(epochs):\n",
    "            current_w = self._w.copy()\n",
    "            w_history[i] = current_w\n",
    "            mse = self.mean_squared_error()\n",
    "            gradient = self.find_gradient()\n",
    "            if i % print_iter == 0:\n",
    "                print(\"epoch: {:6} - loss: {:.6f}\".format(i, mse))\n",
    "            self._w -= learning_rate*gradient\n",
    "        w_ravel = self._w.copy().ravel()\n",
    "        self.intercept_ = w_ravel[0]\n",
    "        self.coef_ = w_ravel[1:]\n",
    "        self._w_history = w_history\n",
    "    def predict(self, X_test):\n",
    "        \"\"\"\n",
    "        This function returns predicted values with weights of this model.\n",
    "        Args:\n",
    "            X_test (ndarray): 2d-array for feature matrix of test data.\n",
    "        \"\"\"\n",
    "        self._X_test = X_test\n",
    "        m = self._X_test.shape[0]\n",
    "        if self._fit_intercept:\n",
    "            X0 = np.ones((m, 1), dtype=float)\n",
    "            self._X_test = np.concatenate([X0, self._X_test], axis=1)\n",
    "        y_pred = np.dot(self._X_test, self._w)\n",
    "        return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:      0 - loss: 1395.016289\n",
      "epoch:   2000 - loss: 0.467521\n",
      "epoch:   4000 - loss: 0.087119\n",
      "epoch:   6000 - loss: 0.016234\n",
      "epoch:   8000 - loss: 0.003025\n",
      "epoch:  10000 - loss: 0.000564\n",
      "epoch:  12000 - loss: 0.000105\n",
      "epoch:  14000 - loss: 0.000020\n",
      "epoch:  16000 - loss: 0.000004\n",
      "epoch:  18000 - loss: 0.000001\n"
     ]
    }
   ],
   "source": [
    "h = GradientDescent(fit_intercept=False)\n",
    "h.fit(X_train, y_train, epochs=20000, learning_rate=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.9992312515155835\n",
      "[6.00011042]\n"
     ]
    }
   ],
   "source": [
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最後我們將自訂的梯度遞減預測器類別應用在真實的 `players` 資料，並且與 Scikit-Learn 預測器類別、正規方程類別所求得的 $w$ 比對。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:      0 - loss: 9727.248118\n",
      "epoch:  30000 - loss: 53.087449\n",
      "epoch:  60000 - loss: 49.159273\n",
      "epoch:  90000 - loss: 48.548584\n",
      "epoch: 120000 - loss: 48.453643\n",
      "epoch: 150000 - loss: 48.438884\n",
      "epoch: 180000 - loss: 48.436589\n",
      "epoch: 210000 - loss: 48.436232\n",
      "epoch: 240000 - loss: 48.436177\n",
      "epoch: 270000 - loss: 48.436168\n"
     ]
    }
   ],
   "source": [
    "X = players['heightMeters'].values.astype(float).reshape(-1, 1)\n",
    "y = players['weightKilograms'].values.astype(float)\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "h = GradientDescent()\n",
    "h.fit(X_train, y_train, epochs=300000, learning_rate=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-104.2096510036928\n",
      "[101.81974607]\n"
     ]
    }
   ],
   "source": [
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([107.57542082,  82.1204843 , 100.4480386 , 105.5390259 ,\n",
       "        95.35705129, 112.66640812,  92.30245891,  92.30245891,\n",
       "        97.39344621,  95.35705129])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 預測\n",
    "y_pred = h.predict(X_valid)\n",
    "y_pred[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "比對 $w$ 與前十筆預測值可以驗證自行定義的 `GradientDescent` 類別與 Scikit-Learn 求解的邏輯相近。\n",
    "\n",
    "我們用簡潔的一段話總結數值預測任務：面對屬於連續型的數值目標向量 $y$，讓電腦程式透過觀察訓練資料 $X^{(train)}$ 與 $y^{(train)}$，基於最小化 $y^{(train)}$ 與 $\\hat{y}^{(train)}$ 間的誤差 $J(w)$，透過正規方程或者梯度遞減的演算方法，尋找出係數向量 $w^*$ 建構出一個 $h(X; w^*)$ 去近似假設存在能完美對應 $X$ 和 $y$ 的 $f$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 標準化與進階的梯度遞減\n",
    "\n",
    "目前自行定義的 `GradientDescent` 類別是屬於單純的最適化手法，為什麼用「單純」來形容？我們再回顧梯度遞減的核心概念：\n",
    "\n",
    "\\begin{equation}\n",
    "w := w - \\alpha \\frac{\\partial J}{\\partial w}\n",
    "\\end{equation}\n",
    "\n",
    "在這個演算方法可以清楚觀察到 $w$ 的更新依據有兩個：學習速率 $\\alpha$ 與梯度 $\\frac{\\partial J}{\\partial w}$，其中學習速率使用一個事先決定的常數，在訓練過程固定不變，梯度也是該次迭代當下的快照；在這樣的設計理念之下，當 $w_i$ 彼此的量值級距差距大，將會發生不效率的最適化。以跑步來比喻，在短距離的場地賽應該要穿著釘鞋與使用九成最大攝氧量的配速競賽、在長距離的路跑賽應該要穿著厚底鞋與使用七成最大攝氧量的配速競賽，然而使用固定的學習速率、只考慮單下的梯度，就像是用同一套裝備與配速去面對距離不同的賽事一般，無法有出色的表現。以 [Kaggle](https://www.kaggle.com/) 網站所下載回來的[艾姆斯房價](https://www.kaggle.com/c/house-prices-advanced-regression-techniques)資料為例，若以其中的 `GrLivArea` 作為特徵矩陣來預測目標向量 `SalePrice`，以 Scikit-Learn 的 `LinearRegression` 預測器類別可以獲知 $w^*$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30774.037736162078\n",
      "[98.50395317]\n"
     ]
    }
   ],
   "source": [
    "train = pd.read_csv(\"https://kaggle-getting-started.s3-ap-northeast-1.amazonaws.com/house-prices/train.csv\")\n",
    "X = train['GrLivArea'].values.reshape(-1, 1)\n",
    "y = train['SalePrice'].values\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "lr = LinearRegression()\n",
    "lr.fit(X_train, y_train)\n",
    "print(lr.intercept_)\n",
    "print(lr.coef_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果使用自行定義的 `GradientDescent` 類別，會發現不論怎麼調整學習速率、增加訓練的迭代次數，$w$ 都離理想值距離甚遠。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:      0 - loss: 38051606006.512634\n",
      "epoch:  50000 - loss: 3240902379.450190\n",
      "epoch: 100000 - loss: 3240693358.485150\n",
      "epoch: 150000 - loss: 3240484776.905393\n",
      "epoch: 200000 - loss: 3240276633.787285\n",
      "epoch: 250000 - loss: 3240068928.209129\n",
      "epoch: 300000 - loss: 3239861659.251170\n",
      "epoch: 350000 - loss: 3239654825.995579\n",
      "epoch: 400000 - loss: 3239448427.526465\n",
      "epoch: 450000 - loss: 3239242462.929857\n"
     ]
    }
   ],
   "source": [
    "h = GradientDescent()\n",
    "h.fit(X_train, y_train, epochs=500000, learning_rate=1e-7) # 無法使用更大的學習速率，誤差會高到發生溢位"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "322.21983727161654\n",
      "[116.36489226]\n"
     ]
    }
   ],
   "source": [
    "print(h.intercept_)\n",
    "print(h.coef_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_contour(X_train, y_train, w_history, w_0_min, w_0_max, w_1_min, w_1_max, w_0_star, w_1_star):\n",
    "    m = X_train.shape[0]\n",
    "    X0 = np.ones((m, 1), dtype=float)\n",
    "    X_train = np.concatenate([X0, X_train], axis=1)\n",
    "    resolution = 100\n",
    "    W_0, W_1 = np.meshgrid(np.linspace(w_0_min, w_0_max, resolution), np.linspace(w_1_min, w_1_max, resolution))\n",
    "    Z = np.zeros((resolution, resolution))\n",
    "    for i in range(resolution):\n",
    "        for j in range(resolution):\n",
    "            w = np.array([W_0[i, j], W_1[i, j]])\n",
    "            y_hat = np.dot(X_train, w)\n",
    "            mse = ((y_hat - y_train).T.dot(y_hat - y_train)) / m\n",
    "            Z[i, j] = mse\n",
    "    epochs = len(w_history)\n",
    "    w_0_history = []\n",
    "    w_1_history = []\n",
    "    for i in range(epochs):\n",
    "        w_0_history.append(w_history[i][0])\n",
    "        w_1_history.append(w_history[i][1])\n",
    "    fig, ax = plt.subplots()\n",
    "    CS = ax.contour(W_0, W_1, Z)\n",
    "    ax.clabel(CS, inline=1, fontsize=10)\n",
    "    ax.plot(w_0_history, w_1_history, \"-\", color=\"blue\")\n",
    "    ax.scatter(w_0_star, w_1_star, marker=\"*\", color=\"red\")\n",
    "    ax.set_xlabel(\"$w_0$\")\n",
    "    ax.set_ylabel(\"$w_1$\", rotation=0)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "這就像是我們先前比喻，沒有針對賽事狀況調整的跑者，在應該加大更新幅度的 $w_0$（平坦的賽道）卻用了和應該縮減更新幅度的 $w_1$（陡峭的賽道）一樣的配速或者裝備。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": [
    "w_history = h._w_history\n",
    "plot_contour(X_train, y_train, w_history, -5000, 35000, -10, 200, lr.intercept_, lr.coef_[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "欲使用梯度遞減來進行最適化，通常會搭配兩種技法來增加效率：\n",
    "\n",
    "1. 特徵矩陣的標準化（Standardization）\n",
    "2. 進階的梯度遞減演算方法\n",
    "\n",
    "特徵矩陣的標準化可以使用在機器學習入門章節介紹過的 Scikit-Learn 轉換器：最小最大標準化（Min-max scaler），標準化後得到的 $w^{(scaled)}$ 要再記得實施「逆」轉換。\n",
    "\n",
    "\\begin{align}\n",
    "\\hat{y} &= X^{(scaled)} w^{(scaled)} \\\\\n",
    "&= w_0^{(scaled)}x_0 + \\sum_i w_i^{(scaled)} x_i^{(scaled)} \\\\\n",
    "&= w_0^{(scaled)} + \\sum_i w_i^{(scaled)} \\frac{x_i - x_i^{(min)}}{x_i^{(max)} - x_i^{(min)}}\n",
    "\\end{align}\n",
    "\n",
    "\\begin{align}\n",
    "w_0 &= w_0^{(scaled)} - \\sum_{i=1} w_i^{(scaled)} \\frac{x_i^{(min)}}{x_i^{(max)} - x_i^{(min)}} \\\\\n",
    "w_i &= \\sum_{i=1} \\frac{w_i^{(scaled)}}{x_i^{(max)} - x_i^{(min)}}\n",
    "\\end{align}\n",
    "\n",
    "將已經過最小最大標準化後的特徵矩陣輸入預測器類別訓練，就能得到的 $w^{(scaled)}$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63674.358095820746\n",
      "[522858.98344032]\n"
     ]
    }
   ],
   "source": [
    "mms = MinMaxScaler()\n",
    "X_scaled = mms.fit_transform(X)\n",
    "y = train['SalePrice'].values\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X_scaled, y, test_size=0.33, random_state=42)\n",
    "lr = LinearRegression()\n",
    "lr.fit(X_train, y_train)\n",
    "print(lr.intercept_) # 截距項\n",
    "print(lr.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:      0 - loss: 38574561936.864601\n",
      "epoch:  10000 - loss: 3197795837.637498\n",
      "epoch:  20000 - loss: 3142864604.714557\n",
      "epoch:  30000 - loss: 3141503145.580052\n",
      "epoch:  40000 - loss: 3141469402.099771\n",
      "epoch:  50000 - loss: 3141468565.774660\n",
      "epoch:  60000 - loss: 3141468545.046516\n",
      "epoch:  70000 - loss: 3141468544.532774\n",
      "epoch:  80000 - loss: 3141468544.520041\n",
      "epoch:  90000 - loss: 3141468544.519726\n",
      "63674.3591206031\n",
      "[522858.97891743]\n"
     ]
    }
   ],
   "source": [
    "h = GradientDescent()\n",
    "h.fit(X_train, y_train, epochs=100000, learning_rate=0.01)\n",
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接著依照「逆」標準化回推 $w$，發現在最小最大標準化之後，就能順利以自定義的 `GradientDescent` 類別進行梯度遞減。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30774.03904554]\n",
      "[98.50395232]\n"
     ]
    }
   ],
   "source": [
    "intercept_rescaled = h.intercept_ - (h.coef_ * mms.data_min_ / mms.data_range_)\n",
    "coef_rescaled = h.coef_ / mms.data_range_\n",
    "print(intercept_rescaled) # 截距項\n",
    "print(coef_rescaled)      # 係數項"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者常態標準化（Standard scaler），同樣要記得對 $w^{(scaled)}$ 實施「逆」轉換。\n",
    "\n",
    "\\begin{align}\n",
    "\\hat{y} &= X^{(scaled)} w^{(scaled)} \\\\\n",
    "&= w_0^{(scaled)}x_0 + \\sum_i w_i^{(scaled)} x_i^{(scaled)} \\\\\n",
    "&= w_0^{(scaled)} + \\sum_i w_i^{(scaled)} \\frac{x_i - \\mu_{x_i}}{\\sigma_{x_i}}\n",
    "\\end{align}\n",
    "\n",
    "\\begin{align}\n",
    "w_0 &= w_0^{(scaled)} - \\sum_{i=1} w_i^{(scaled)} \\frac{\\mu_{x_i}}{\\sigma_{x_i}} \\\\\n",
    "w_i &= \\sum_{i=1} \\frac{w_i^{(scaled)}}{\\sigma_{x_i}}\n",
    "\\end{align}\n",
    "\n",
    "將已經過常態標準化後的特徵矩陣輸入預測器類別訓練，就能得到的 $w^{(scaled)}$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "180053.20294084703\n",
      "[51744.16536903]\n"
     ]
    }
   ],
   "source": [
    "ss = StandardScaler()\n",
    "X_scaled = ss.fit_transform(X)\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X_scaled, y, test_size=0.33, random_state=42)\n",
    "lr = LinearRegression()\n",
    "lr.fit(X_train, y_train)\n",
    "print(lr.intercept_) # 截距項\n",
    "print(lr.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:      0 - loss: 38574730599.218040\n",
      "epoch:   1000 - loss: 3763987629.644883\n",
      "epoch:   2000 - loss: 3152443788.694848\n",
      "epoch:   3000 - loss: 3141662791.806108\n",
      "epoch:   4000 - loss: 3141471997.043127\n",
      "epoch:   5000 - loss: 3141468606.167773\n",
      "epoch:   6000 - loss: 3141468545.625978\n",
      "epoch:   7000 - loss: 3141468544.539675\n",
      "epoch:   8000 - loss: 3141468544.520079\n",
      "epoch:   9000 - loss: 3141468544.519723\n",
      "180053.2025929845\n",
      "[51744.16539333]\n"
     ]
    }
   ],
   "source": [
    "h = GradientDescent()\n",
    "h.fit(X_train, y_train, epochs=10000, learning_rate=0.001)\n",
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接著依照「逆」標準化回推 $w$，發現在常態標準化之後，就能順利以自定義的 `GradientDescent` 類別進行梯度遞減。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30774.0373182]\n",
      "[98.50395322]\n"
     ]
    }
   ],
   "source": [
    "intercept_rescaled = h.intercept_ - h.coef_ * ss.mean_ / ss.scale_\n",
    "coef_rescaled = h.coef_ / ss.scale_\n",
    "print(intercept_rescaled) # 截距項\n",
    "print(coef_rescaled)      # 係數項"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外一種為單純的梯度遞減增加效率的手法是進階的梯度遞減，這些演算方法目前仍處於蓬勃發展的階段，已經廣泛被資料科學家、機器學習工程師應用的有 Momentum、AdaGrad(Adaptive Gradient Descent)、RMSprop(Root mean square propagation)與 Adam(Adaptive moment estimation)。與單純梯度遞減相較，各個進階梯度遞減都試著從學習速率與梯度這兩方面著手調整，其一是引進調適的學習速率（Adaptive methods），如果距離 $J(w)$ 低點遠就用大的學習速率、反之距離近就用小的學習速率；其二是記錄從訓練開始的梯度量值，藉由過去已實現的梯度來判斷和 $J(w)$ 低點的相對位置，如果歷史梯度都很大，表示離低點遠，如果歷史梯度都很小，表示離低點進。就像是一個懂得在不同距離賽事、穿著適當裝備以及使用相應配速的跑者（在中距離場地賽穿著釘鞋與使用九成最大攝氧量配速、在長距離路跑賽穿著厚底鞋與使用七成最大攝氧量配速）。\n",
    "\n",
    "我們簡單地以 AdaGrad 為例，AdaGrad 將原本單純梯度遞減的式子改寫為：\n",
    "\n",
    "\\begin{equation}\n",
    "ssg = \\sum^{t-1} (\\frac{\\partial J}{\\partial w})^2\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "w := w -\\alpha \\frac{1}{\\epsilon + \\sqrt{ssg}} \\frac{\\partial J}{\\partial w}\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "where \\; \\epsilon = 10^{-6}\n",
    "\\end{equation}\n",
    "\n",
    "AdaGrad 演算方法針對不同 $w_i$ 記錄其歷史梯度的平方和藉此來調適學習速率，因為放在分母的緣故，當歷史梯度的平方和愈大，會調降學習速率；反之當歷史梯度的平方和愈小，會調升學習速率，$\\epsilon$ 會設定一個極小值（例如 `tf.keras` 使用 `1e-06`）避免分母為零的情況發生。\n",
    "\n",
    "自定義一個 `AdaGrad` 類別繼承 `GradientDescent` 類別並改寫其 `fit()` 方法由原本的單純梯度遞減變為 AdaGrad。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AdaGrad(GradientDescent):\n",
    "    \"\"\"\n",
    "    This class defines the Adaptive Gradient Descent algorithm for linear regression.\n",
    "    \"\"\"\n",
    "    def fit(self, X_train, y_train, epochs=10000, learning_rate=0.01, epsilon=1e-06):\n",
    "        self._X_train = X_train.copy()\n",
    "        self._y_train = y_train.copy()\n",
    "        self._m = self._X_train.shape[0]\n",
    "        if self._fit_intercept:\n",
    "            X0 = np.ones((self._m, 1), dtype=float)\n",
    "            self._X_train = np.concatenate([X0, self._X_train], axis=1)\n",
    "        n = self._X_train.shape[1]\n",
    "        self._w = np.random.rand(n)\n",
    "        # 初始化 ssg\n",
    "        ssg = np.zeros(n, dtype=float)\n",
    "        n_prints = 10\n",
    "        print_iter = epochs // n_prints\n",
    "        w_history = dict()\n",
    "        for i in range(epochs):\n",
    "            current_w = self._w.copy()\n",
    "            w_history[i] = current_w\n",
    "            mse = self.mean_squared_error()\n",
    "            gradient = self.find_gradient()\n",
    "            ssg += gradient**2\n",
    "            ada_grad = gradient / (epsilon + ssg**0.5)\n",
    "            if i % print_iter == 0:\n",
    "                print(\"epoch: {:6} - loss: {:.6f}\".format(i, mse))\n",
    "            # 以 adaptive gradient 更新 w\n",
    "            self._w -= learning_rate*ada_grad\n",
    "        w_ravel = self._w.copy().ravel()\n",
    "        self.intercept_ = w_ravel[0]\n",
    "        self.coef_ = w_ravel[1:]\n",
    "        self._w_history = w_history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30774.037736162078\n",
      "[98.50395317]\n"
     ]
    }
   ],
   "source": [
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "lr = LinearRegression()\n",
    "lr.fit(X_train, y_train)\n",
    "print(lr.intercept_) # 截距項\n",
    "print(lr.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:      0 - loss: 38445917993.077576\n",
      "epoch:  50000 - loss: 3146435374.819119\n",
      "epoch: 100000 - loss: 3141887793.680318\n",
      "epoch: 150000 - loss: 3141504799.902792\n",
      "epoch: 200000 - loss: 3141471686.153493\n",
      "epoch: 250000 - loss: 3141468816.799205\n",
      "epoch: 300000 - loss: 3141468568.118027\n",
      "epoch: 350000 - loss: 3141468546.564972\n",
      "epoch: 400000 - loss: 3141468544.696979\n",
      "epoch: 450000 - loss: 3141468544.535080\n",
      "30773.92524140127\n",
      "[98.50401916]\n"
     ]
    }
   ],
   "source": [
    "h = AdaGrad()\n",
    "h.fit(X_train, y_train, epochs=500000, learning_rate=100)\n",
    "print(h.intercept_) # 截距項\n",
    "print(h.coef_)      # 係數項"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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": [
    "w_history = h._w_history\n",
    "plot_contour(X_train, y_train, w_history, -5000, 35000, -10, 200, lr.intercept_, lr.coef_[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "改採用 `AdaGrad` 類別後發現即便沒有進行特徵矩陣的標準化，也能夠順利最適化 $w$。在實際採用梯度遞減進行最適化時，通常會將標準化與進階演算手法兩者搭配運作，這也是為什麼在 [Kaggle](https://www.kaggle.com/) 網站上看到很多採用高階機器學習框架的專案範例，都會對特徵矩陣做標準化並指定參數 `optimizer` 為 `RMSprop`、`Adam` 或 `Adagrad` 的緣由。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 延伸閱讀\n",
    "\n",
    "1. Machine Learning Basics. In: Ian Goodfellow ,Yoshua Bengio, and Aaron Courville, Deep Learning (https://www.amazon.com/Deep-Learning-Adaptive-Computation-Machine/dp/0262035618/)\n",
    "2. Sebastian Ruder: An overview of gradient descent optimization algorithms (https://ruder.io/optimizing-gradient-descent/index.html)\n",
    "3. Training Models. In: Aurélien Géron, Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (https://www.amazon.com/Hands-Machine-Learning-Scikit-Learn-TensorFlow/dp/1492032646/)\n",
    "4. Normal Equation (http://mlwiki.org/index.php/Normal_Equation)\n",
    "5. Computational complexity (https://en.wikipedia.org/wiki/Computational_complexity)\n",
    "6. Gradient descent (https://en.wikipedia.org/wiki/Gradient_descent)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python Machine Learning",
   "language": "python",
   "name": "pyml"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}