{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 表現的評估\n",
    "\n",
    "我們先載入這個章節範例程式碼中會使用到的第三方套件、模組或者其中的部分類別、函式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyvizml import CreateNBAData\n",
    "from datetime import datetime\n",
    "import requests\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何評估機器學習演算方法\n",
    "\n",
    "評估機器學習演算方法是否能夠針對特定任務（包含數值預測、類別預測）運作，必須設計能夠量化演算方法表現的指標。評估迴歸模型與分類器表現的指標與尋找係數向量 $w$ 藉此創建出 $h(X; w)$ 的原理相同，差別在於究竟要比對哪一組目標向量 $y$？\n",
    "\n",
    "我們找尋係數向量的依據，乃是基於最小化 $y^{(train)}$ 與 $\\hat{y}^{(train)}$ 之間的誤差，，其中數值預測任務是以均方誤差（Mean squared error, MSE）來表示，$m$ 代表觀測值筆數。\n",
    "\n",
    "\\begin{equation}\n",
    "Minimize \\; \\frac{1}{m}\\sum_{i}{(y^{(train)}_i - \\hat{y_i}^{(train)})^2}\n",
    "\\end{equation}\n",
    "\n",
    "類別預測任務則是以誤分類數（Error）來表示。\n",
    "\n",
    "\\begin{equation}\n",
    "Minimize \\; \\sum_{i} \\mid y^{(train)}_i \\neq \\hat{y_i}^{(train)} \\mid\n",
    "\\end{equation}\n",
    "\n",
    "這是因為機器學習**假設**存在了一個函式 $f$ 能夠完美描述特徵矩陣與目標向量的關係，但我們不能夠將**假設**存在的 $f$ 拿來與創建出的 $h$ 擺在桌面上比較，因此藉由比較 $y^{(train)}$ 與 $\\hat{y}^{(train)}$ 來達成。評估迴歸模型與分類器的表現同樣是比較預測目標向量與實際目標向量之間的誤差，但是改為驗證資料或測試資料的目標向量。數值預測任務的表現評估以均方誤差衡量，$m$ 代表觀測值筆數。\n",
    "\n",
    "\\begin{equation}\n",
    "MSE_{valid} = \\frac{1}{m}\\sum_{i}{(y^{(valid)}_i - \\hat{y_i}^{(valid)})^2}\n",
    "\\end{equation}\n",
    "\n",
    "類別預測任務的表現評估以誤分類數衡量。\n",
    "\n",
    "\\begin{equation}\n",
    "Error_{valid} = \\sum_{i} \\mid y^{(valid)}_i \\neq \\hat{y_i}^{(valid)} \\mid\n",
    "\\end{equation}\n",
    "\n",
    "機器學習專案中的訓練、驗證來自具備已實現數值或標籤資料集，測試則來自未實現數值或標籤資料集；迴歸模型與分類器在從未見過的測試資料上之表現將決定它被部署到正式環境開始運作時的成敗，在現實世界中要評估機器學習演算方法在測試資料上的表現，在時間與金錢成本上都比在驗證資料上實施來得高出許多，像是設計類似實驗組與對照組的測試環境、等待一段時間才會實現數值或標籤。\n",
    "\n",
    "挑選機器學習演算方法的評估指標除了與任務種類相關，也與模型的應用場景有關，例如即便同屬於疾病的檢測分類模型，針對傳染疾病或罕見疾病所選擇的指標就有可能不同，這是由於和「誤分類」所衍生出的成本連動所致。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 評估數值預測任務的表現\n",
    "\n",
    "數值預測任務的表現評估以均方誤差來衡量 $y^{(valid)}$ 與 $\\hat{y}^{(valid)}$ 之間的差異，均方誤差愈大推論 $h_w$ 跟 $f$ 的相似度愈低，反之均方誤差愈小推論 $h$ 與 $f$ 的相似度愈高。使用 Scikit-Learn 定義好的 `mean_squared_error` 函式可以協助我們計算兩個目標向量之間的均方誤差。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating players df...\n",
      "Creating players df...\n",
      "Creating player stats df...\n"
     ]
    }
   ],
   "source": [
    "# create_player_stats_df() 方法要對 data.nba.net 發出數百次的 HTTP 請求，等待時間會較長，要請讀者耐心等候\n",
    "cnd = CreateNBAData(season_year=2019)\n",
    "player_stats = cnd.create_player_stats_df()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.74701649791643"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = player_stats['heightMeters'].values.astype(float).reshape(-1, 1)\n",
    "y = player_stats['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)\n",
    "y_pred = h.predict(X_valid)\n",
    "mse_valid = mean_squared_error(y_valid, y_pred)\n",
    "mse_valid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "亦可以自訂均方誤差的函式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def meanSquaredError(y_true, y_pred):\n",
    "    error = (y_true - y_pred)\n",
    "    squared_error = error**2\n",
    "    mean_squared_error = np.mean(squared_error)\n",
    "    return mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.74701649791643"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mse_valid = meanSquaredError(y_valid, y_pred)\n",
    "mse_valid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外一個也常被用來評估數值預測任務表現的指標是平均絕對誤差（Mean absolute error），平均絕對誤差和均方誤差相同之處在於他們都能精確捕捉預測失準的量值，無論是低估或者高估，經過平方或絕對值的運算都會成為正數被詳實地累積起來；相異之處在於均方誤差對於預測失準較多的離群值（Outliers）具有放大的效果（平方），而平均絕對誤差則不具有這樣類似加權的效果，因此當離群值在任務預測失準所衍生的成本也大幅上升的應用場景中，就比平均絕對誤差更適合使用，表示迴歸模型的選擇和調校上會傾向避免預測失準較多的情況。\n",
    "\n",
    "使用 Scikit-Learn 定義好的 `mean_absolute_error` 函式可以協助我們計算兩個目標向量之間的平均絕對誤差。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.251994295197642"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mae_valid = mean_absolute_error(y_valid, y_pred)\n",
    "mae_valid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "亦可以自訂平均絕對誤差的函式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def meanAbsoluteError(y_true, y_pred):\n",
    "    error = (y_true - y_pred)\n",
    "    absolute_error = np.abs(error)\n",
    "    mean_absolute_error = np.mean(absolute_error)\n",
    "    return mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.251994295197642"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mae_valid = meanAbsoluteError(y_valid, y_pred)\n",
    "mae_valid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 評估類別預測任務的表現\n",
    "\n",
    "類別預測任務的表現評估以誤分類數來衡量 $y^{(valid)}$ 與 $\\hat{y}^{(valid)}$ 之間的差異，誤分類數愈多推論 $h$ 跟 $f$ 的相似度愈低，反之誤分類數愈少推論 $h$ 與 $f$ 的相似度愈高。分類器常使用的評估指標比迴歸模型為多，像是準確率（Accuracy）、精確率（Precision）、召回率（Recall）與 F1-score 等。這些評估指標乍看之下會讓我們眼花撩亂，但實際上只要能夠拆解正確分類 $y^{(valid)} = \\hat{y}^{(valid)}$ 與錯誤分類 $y^{(valid)} \\neq \\hat{y}^{(valid)}$ 的組成，就可以理解評估分類器指標的設計哲學。\n",
    "\n",
    "正確分類與錯誤分類各自都還能拆解成兩種情境：\n",
    "\n",
    "- 正確分類\n",
    "    - 真陰性（True negative, TN）：$y^{(valid)}=0$ 並且 $\\hat{y}^{(valid)}=0$\n",
    "    - 真陽性（True positive, TP）：$y^{(valid)}=1$ 並且 $\\hat{y}^{(valid)}=1$\n",
    "- 錯誤分類\n",
    "    - 偽陰性（False negative, FN）：$y^{(valid)}=1$ 並且 $\\hat{y}^{(valid)}=0$\n",
    "    - 偽陽性（False positive, FP）：$y^{(valid)}=0$ 並且 $\\hat{y}^{(valid)}=1$\n",
    "\n",
    "這四種情境能夠以一個被稱作混淆矩陣（Confusion matrix）的 $2 \\times 2$ 矩陣表達。\n",
    "\n",
    "||$\\hat{y}^{(valid)}=0$|$\\hat{y}^{(valid)}=1$|\n",
    "|---|---|---|\n",
    "|$y^{(valid)}=0$|真陰性（True negative, TN）|偽陽性（False positive, FP）|\n",
    "|$y^{(valid)}=1$|偽陰性（False negative, FN）|真陽性（True positive, TP）|\n",
    "\n",
    "前述眼花撩亂的評估指標，其實都能從組成混淆矩陣的四個象限衍生而得，使用 Scikit-Learn 定義好的 `confusion_matrix` 函式可以協助我們創建兩個目標向量之間正確分類、錯誤分類所組成的混淆矩陣。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[60, 16],\n",
       "       [20, 70]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = player_stats[['apg', 'rpg']].values.astype(float)\n",
    "pos_dict = {\n",
    "    0: 'G',\n",
    "    1: 'F'\n",
    "}\n",
    "pos = player_stats['pos'].values\n",
    "y = np.array([0 if p[0] == 'G' else 1 for p in pos])\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "h = LogisticRegression()\n",
    "h.fit(X_train, y_train)\n",
    "y_pred = h.predict(X_valid)\n",
    "cm = confusion_matrix(y_valid, y_pred)\n",
    "cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "亦可以自訂創建混淆矩陣的函式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def confusionMatrix(y_true, y_pred):\n",
    "    n_unique = np.unique(y_true).size\n",
    "    cm = np.zeros((n_unique, n_unique), dtype=int)\n",
    "    for i in range(n_unique):\n",
    "        for j in range(n_unique):\n",
    "            n_obs = np.sum(np.logical_and(y_true == i, y_pred == j))\n",
    "            cm[i, j] = n_obs\n",
    "    return cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[60, 16],\n",
       "       [20, 70]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm = confusionMatrix(y_valid, y_pred)\n",
    "cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "準確率（Accuracy）是類別預測任務最常用的評估指標，分子是正確分類的觀測值個數，即真陰性加真陽性；分母是四個象限的觀測值個數總和，即目標向量的長度，準確率愈高代表分類器的表現愈好、反之則代表分類器的表現愈差。\n",
    "\n",
    "\\begin{equation}\n",
    "Accuracy = \\frac{TN + TP}{TN + TP + FN + FP}\n",
    "\\end{equation}\n",
    "\n",
    "使用 Scikit-Learn 定義好的 `accuracy_score` 函式可以協助我們計算準確率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7831325301204819"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy = accuracy_score(y_valid, y_pred)\n",
    "accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "準確率的概念直觀，但是在一些狀況中並不這麼適合評估分類器的表現，像是陽性事件發生率極低的應用場景，例如罕見疾病或市場黑天鵝事件的預測任務。如果設計出一個樸素的分類器（Dummy classifier），它以目標向量中出現頻率最高的類別作為預測依據，如果以 1000 個觀測值中僅有 1 個陽性的情況舉例，準確率可以達到 0.999，是一個乍看之下非常漂亮的評估指標。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.999"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_true = np.zeros(1000, dtype=int)\n",
    "y_true[-1] = 1\n",
    "y_pred = np.zeros(1000, dtype=int)\n",
    "accuracy = accuracy_score(y_true, y_pred)\n",
    "accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然而這個分類器對預測陽性事件發生率極低的任務卻是完全無用處，亦即使用準確率來評估並不適合。這時使用精確率（Precision）與召回率（Recall）來進行評估會更加適合。精確率的分子是真陽性、分母是真陽性加偽陽性，它的意涵是分類器在所有預測為陽性的觀測值中，正確預測的觀測值數為多少；召回率的分子是真陽性、分母是真陽性加偽陰性，它的意涵是分類器在所有陽性的觀測值中，正確預測的觀測值數為多少。\n",
    "\n",
    "\\begin{align}\n",
    "Precision = \\frac{TP}{TP + FP} \\\\\n",
    "Recall = \\frac{TP}{TP + FN}\n",
    "\\end{align}\n",
    "\n",
    "相較準確率，精確率與召回率更專注評估分類器對陽性事件的預測能力，兩個指標愈高，代表模型的表現愈好。精確率如果表現要好除了真陽性高，偽陽性亦要想辦法降低，而召回率同樣若表現要好除了真陽性高，偽陰性亦要想辦法降低，因此在選擇採用精確率與召回率時，常會延伸探討偽陽性或偽陰性所衍生的誤判成本。採用精確率代表的要盡可能降低偽陽性，這表示的是偽陽性的成本高，意味著是誤判為陽性事件的成本高（例如誤診而進行高風險的手術）；採用準確率代表的是要儘可能降低偽陰性，這表示的是偽陰性的成本高，意味著是誤判為陰性事件的成本高（例如誤診而導致超級傳播者沒有隔離而進入社區）。\n",
    "\n",
    "使用 Scikit-Learn 定義好的 `precision_score` 與 `recall_score` 函式可以協助我們計算精確率與召回率，這時可以看到樸素分類器在精確率和召回率都得到了最低的評估值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "precision = precision_score(y_true, y_pred, zero_division=0)\n",
    "recall = recall_score(y_true, y_pred)\n",
    "print(precision)\n",
    "print(recall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "評估分類模型的表現時可以同時將精確率與召回率納入考量，運用一個係數 $\\beta$ 加權兩個指標合成為一個稱為 F-score 的指標。\n",
    "\n",
    "\\begin{equation}\n",
    "F_{\\beta} = (1 + \\beta^2) \\cdot \\frac{precision \\cdot recall}{(\\beta^2 \\cdot precision) + recall}\n",
    "\\end{equation}\n",
    "\n",
    "$\\beta$ 係數的值可以表示對精確率或召回率的相對重視程度，如果偽陽性的成本遠高於偽陰性的成本，代表百分百重視精確率，這時代入 $\\beta = 0$ F-score 就會是精確率；如果偽陰性的成本遠高於偽陽性的成本，代表百分百重視召回率，這時代入 $\\beta = \\infty$ F-score 就會是召回率；如果偽陽性的成本和偽陰性的成本相當，代表兩個指標同等重要，這時代入 $\\beta = 1$ F-score 就被稱為 F1-score，指標愈高，代表模型的表現愈好。\n",
    "\n",
    "\\begin{equation}\n",
    "F_{1} = 2 \\cdot \\frac{precision \\cdot recall}{precision + recall}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 Scikit-Learn 定義好的 `f1_score` 函式可以協助我們計算 F1-score，同樣可以看到樸素分類器依然在 F1-score 獲得了最低的評估值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1 = f1_score(y_true, y_pred)\n",
    "f1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 自訂計算評估指標的類別 `ClfMetrics`\n",
    "\n",
    "我們亦可以根據混淆矩陣自訂分類器評估指標的類別。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClfMetrics:\n",
    "    \"\"\"\n",
    "    This class calculates some of the metrics of classifier including accuracy, precision, recall, f1 according to confusion matrix.\n",
    "    Args:\n",
    "        y_true (ndarray): 1d-array for true target vector.\n",
    "        y_pred (ndarray): 1d-array for predicted target vector.\n",
    "    \"\"\"\n",
    "    def __init__(self, y_true, y_pred):\n",
    "        self._y_true = y_true\n",
    "        self._y_pred = y_pred\n",
    "    def confusion_matrix(self):\n",
    "        \"\"\"\n",
    "        This function returns the confusion matrix given true/predicted target vectors.\n",
    "        \"\"\"\n",
    "        n_unique = np.unique(self._y_true).size\n",
    "        cm = np.zeros((n_unique, n_unique), dtype=int)\n",
    "        for i in range(n_unique):\n",
    "            for j in range(n_unique):\n",
    "                n_obs = np.sum(np.logical_and(self._y_true == i, self._y_pred == j))\n",
    "                cm[i, j] = n_obs\n",
    "        self._tn = cm[0, 0]\n",
    "        self._tp = cm[1, 1]\n",
    "        self._fn = cm[0, 1]\n",
    "        self._fp = cm[1, 0]\n",
    "        return cm\n",
    "    def accuracy_score(self):\n",
    "        \"\"\"\n",
    "        This function returns the accuracy score given true/predicted target vectors.\n",
    "        \"\"\"\n",
    "        cm = self.confusion_matrix()\n",
    "        accuracy = (self._tn + self._tp) / np.sum(cm)\n",
    "        return accuracy\n",
    "    def precision_score(self):\n",
    "        \"\"\"\n",
    "        This function returns the precision score given true/predicted target vectors.\n",
    "        \"\"\"\n",
    "        precision = self._tp / (self._tp + self._fp)\n",
    "        return precision  \n",
    "    def recall_score(self):\n",
    "        \"\"\"\n",
    "        This function returns the recall score given true/predicted target vectors.\n",
    "        \"\"\"\n",
    "        recall = self._tp / (self._tp + self._fn)\n",
    "        return recall\n",
    "    def f1_score(self, beta=1):\n",
    "        \"\"\"\n",
    "        This function returns the f1 score given true/predicted target vectors.\n",
    "        Args:\n",
    "            beta (int, float): Can be used to generalize from f1 score to f score.\n",
    "        \"\"\"\n",
    "        precision = self.precision_score()\n",
    "        recall = self.recall_score()\n",
    "        f1 = (1 + beta**2)*precision*recall / ((beta**2 * precision) + recall)\n",
    "        return f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos = player_stats['pos'].values\n",
    "y = np.array([0 if p[0] == 'G' else 1 for p in pos])\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "h = LogisticRegression()\n",
    "h.fit(X_train, y_train)\n",
    "y_pred = h.predict(X_valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[60, 16],\n",
       "       [20, 70]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 混淆矩陣\n",
    "clf_metrics = ClfMetrics(y_valid, y_pred)\n",
    "clf_metrics.confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7831325301204819"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 準確率\n",
    "clf_metrics.accuracy_score()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7777777777777778"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 精確率\n",
    "clf_metrics.precision_score()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.813953488372093"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 召回率\n",
    "clf_metrics.recall_score()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7954545454545455"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# F1-score\n",
    "clf_metrics.f1_score()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 誤差的來源\n",
    "\n",
    "在機器學習的訓練階段，我們透過比較訓練資料中的預測目標向量與實際目標向量之間的誤差，來作為尋找係數向量的依據；在機器學習的驗證階段，我們透過比較驗證資料中的預測目標向量與實際目標向量之間的誤差，來評估模型的表現；而最後在機器學習的測試階段，我們終究要面對在前兩個階段未碰觸、尚未實現、不具備目標值或標籤的測試資料，不論是透過實驗設計或者等待一段時間讓未知資料的數值或標籤實現，最終使得機器學習演算方法表現一翻兩瞪眼的是比較測試資料中預測目標向量與實際目標向量之間的誤差階段。\n",
    "\n",
    "數值預測任務的表現評估以均方誤差衡量，$m$ 代表觀測值筆數。\n",
    "\n",
    "\\begin{equation}\n",
    "MSE_{test} = \\frac{1}{m}\\sum_{i}{(y^{(test)}_i - \\hat{y_i}^{(test)})^2}\n",
    "\\end{equation}\n",
    "\n",
    "類別預測任務的表現評估以誤分類數衡量。\n",
    "\n",
    "\\begin{equation}\n",
    "Error_{test} = \\sum_{i} \\mid y^{(test)}_i \\neq \\hat{y_i}^{(test)} \\mid\n",
    "\\end{equation}\n",
    "\n",
    "一個訓練後的迴歸模型或分類器，其誤差來源可以大抵分為訓練誤差（Training error）與測試誤差（Test error），在已實現、具備目標值或標籤的訓練、驗證資料上表現良好，表示它的訓練誤差小；在尚未實現、不具備目標值或標籤的測試資料上表現良好，表示它的測試誤差小（又稱為泛化能力強），於是乎機器學習演算方法的目標是將訓練誤差以及測試誤差降低。不過在現實世界中，處於訓練與驗證階段時對於測試資料是一無所知的，又該如何在只能接觸到訓練與驗證資料時去降低測試誤差？仰賴訓練、驗證與測試資料的 i.i.d 假設，資料中每一筆觀測值彼此獨立（Independent）、訓練、驗證與測試資料來自同樣分佈（Identically distributed）的母體。如果假設不成立，用訓練資料產生 $h_w$ 來逼近 $f$ 的做法就顯得毫無意義了。因此我們可以將機器學習演算方法的目標修正簡化為：\n",
    "\n",
    "1. 減少訓練誤差\n",
    "2. 減少訓練誤差與測試誤差的間距\n",
    "\n",
    "為了減少訓練誤差，我們可以透過交叉驗證（Cross validation）的技巧消弭訓練與驗證資料切割所造成的誤差、增加梯度遞減的訓練次數或者增加特徵矩陣的欄位；而為了減少訓練誤差與測試誤差的間距，我們可以引用正規化（Regularization）的技巧。\n",
    "\n",
    "## 減少訓練誤差\n",
    "\n",
    "在前述章節中，我們在切割訓練與驗證資料時都有納入 `random_state=42` 這是為了固定某個特定的隨機狀態，如果沒有指定這個參數，每一次資料劃分為訓練和驗證的情況都會不同，這會影響係數向量 $w$ 求解、$h_w$ 的創建進而影響 $\\hat{y}$。如果希望避免某個隨機狀態劃分出了不夠均勻的訓練和驗證資料，可以使用交叉驗證的技巧，將資料拆分為 `k` 個不重複的子集合，進而可以在這些子集合上重複進行訓練和驗證，在第 `i` 次迭代中將第 `i` 個子集合當作驗證資料，其餘當作訓練資料，最後取平均值來評估誤差。\n",
    "\n",
    "使用 Scikit-Learn 定義好的 `KFold` 類別可以協助我們獲得交叉驗證時訓練與驗證資料的位置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[55.07839694995417, 51.7810202008688, 50.50037007540896, 38.95499731929424, 55.212983938023825]\n",
      "50.30555369671\n"
     ]
    }
   ],
   "source": [
    "shuffled_index = player_stats.index.values.copy()\n",
    "np.random.seed(42)\n",
    "np.random.shuffle(shuffled_index)\n",
    "X = player_stats['heightMeters'].values.astype(float)[shuffled_index].reshape(-1, 1)\n",
    "y = player_stats['weightKilograms'].values.astype(float)[shuffled_index]\n",
    "kf = KFold(n_splits=5)\n",
    "h = LinearRegression()\n",
    "mse_scores = []\n",
    "for train_index, valid_index in kf.split(X):\n",
    "    X_train, X_valid = X[train_index], X[valid_index]\n",
    "    y_train, y_valid = y[train_index], y[valid_index]\n",
    "    h.fit(X_train, y_train)\n",
    "    y_pred = h.predict(X_valid)\n",
    "    mse = mean_squared_error(y_valid, y_pred)\n",
    "    mse_scores.append(mse)\n",
    "mean_mse_scores = np.mean(mse_scores)\n",
    "print(mse_scores)\n",
    "print(mean_mse_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": [
    "fig= plt.figure()\n",
    "ax = plt.axes()\n",
    "ax.plot(mse_scores, marker='.', markersize=10)\n",
    "ax.axhline(mean_mse_scores, color='red', linestyle=\"--\")\n",
    "ax.set_title('Use average MSE in KFold cross validation')\n",
    "ax.set_xticks(range(5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在梯度遞減開始前隨機初始化的 $w$ 的訓練誤差是高的，隨著訓練次數增加而漸漸減少，這在數值預測與類別預測任務中我們已經看過不少範例；而增加特徵矩陣的欄位可以使用 Scikit-Learn 定義好的 `PolynomialFeatures` 類別創建高次項觀察訓練誤差在不同 `degree` 下的訓練誤差，以迴歸模型為例，當訓練誤差很高的時候模型處於「配適不足」（Underfitting）的狀態，像是 `degree=0` 的時候。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = player_stats['heightMeters'].values.astype(float).reshape(-1, 1)\n",
    "X_plot = np.linspace(X.min() - 0.1, X.max().max() + 0.1).reshape(-1, 1)\n",
    "y = player_stats['weightKilograms'].values.astype(float)\n",
    "degrees = range(9)\n",
    "y_plots = []\n",
    "training_errors = []\n",
    "for d in degrees:\n",
    "    poly = PolynomialFeatures(d)\n",
    "    X_poly = poly.fit_transform(X)\n",
    "    X_train, X_valid, y_train, y_valid = train_test_split(X_poly, y, test_size=0.33, random_state=42)\n",
    "    h = LinearRegression()\n",
    "    h.fit(X_train, y_train)\n",
    "    y_pred = h.predict(X_train)\n",
    "    training_error = mean_squared_error(y_train, y_pred)\n",
    "    training_errors.append(training_error)\n",
    "    X_plot_poly = poly.fit_transform(X_plot)\n",
    "    y_pred = h.predict(X_plot_poly)\n",
    "    y_plots.append(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = X.ravel()\n",
    "fig, axes = plt.subplots(3, 3, figsize=(12, 6), sharey=True)\n",
    "for k, d, te, y_p in zip(range(9), degrees, training_errors, y_plots):\n",
    "    i = k // 3\n",
    "    j = k % 3\n",
    "    x_p = X_plot.ravel()\n",
    "    axes[i, j].scatter(x, y, s=5, alpha=0.5)\n",
    "    axes[i, j].plot(x_p, y_p, color=\"red\")\n",
    "    axes[i, j].set_ylim(60, 150)\n",
    "    axes[i, j].set_title(\"Degree: {}\\nTraining Error: {:.4f}\".format(d, te))\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了為特徵矩陣加入更多的變數，減少訓練誤差的方式還有超參數（Hyperparameter）調校、變換其他機器學習演算方法或者製造衍生變數（特徵工程）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 減少訓練誤差與測試誤差的間距\n",
    "\n",
    "在試圖減少訓練誤差的過程，很有可能伴隨而來的是驗證或測試誤差的升高，這是因為模型對於訓練資料過於熟悉，而降低了它的泛化能力。例如跑者若是固定在平坦的操場訓練，在參與路跑時候很可能因為地形起伏而導致比賽表現不如訓練，這樣的狀態我們稱之為「過度配適」（Overfitting）。欲避免過度配適最直觀的解法就是減少特徵矩陣的變數，但這又會與我們原本希望減少訓練誤差的出發點相左，有沒有什麼辦法讓機器學習演算法保留多個變數的特徵，但又不會產生過度配飾呢？這時可以求助「正規化」（Regularization）。正規化技巧是透過使用一個參數 $\\lambda$ 在訓練過程中對係數向量壓抑，以數值預測任務為例，在原本的誤差函式 $J(w)$ 加上 $\\lambda w^Tw$ 抑制係數向量，又被稱為 L2 正規化。\n",
    "\n",
    "\\begin{equation}\n",
    "J(w) = \\frac{1}{m}(\\parallel Xw - y \\parallel^2 + \\lambda w^Tw)\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 Xw - y\\parallel^2) + \\frac{\\partial}{\\partial w}\\lambda w^Tw) \\\\\n",
    "&= \\frac{1}{m}(\\frac{\\partial}{\\partial w}(Xw - y)^T(Xw-y) + \\frac{\\partial}{\\partial w}\\lambda w^Tw)\\\\\n",
    "&= \\frac{1}{m}(\\frac{\\partial}{\\partial w}(w^TX^TXw - w^TX^Ty - y^TXw + y^Ty) + \\frac{\\partial}{\\partial w}\\lambda w^Tw) \\\\\n",
    "&= \\frac{1}{m}(\\frac{\\partial}{\\partial w}(w^TX^TXw - (Xw)^Ty - (Xw)^Ty + y^Ty) + \\frac{\\partial}{\\partial w}\\lambda w^Tw)\\\\\n",
    "&= \\frac{1}{m}(\\frac{\\partial}{\\partial w}(w^TX^TXw - 2(Xw)^Ty + y^Ty) + \\frac{\\partial}{\\partial w}\\lambda w^Tw) \\\\\n",
    "&= \\frac{1}{m}(2X^TXw - 2X^Ty + 2\\lambda w) \\\\\n",
    "&= \\frac{2}{m}(X^TXw - X^Ty + \\lambda w) \\\\\n",
    "&= \\frac{2}{m}(X^T(Xw - y) + \\lambda w)) \\\\\n",
    "&= \\frac{2}{m}(X^T(\\hat{y} - y) + \\lambda w))\n",
    "\\end{align}\n",
    "\n",
    "就可以寫出具備 L2 正規化效果梯度遞減的式子。\n",
    "\n",
    "\\begin{gather}\n",
    "w := w - \\alpha \\frac{2}{m}(X^T(\\hat{y} - y) + \\lambda w)) \\\\\n",
    "w := (w - \\alpha \\frac{2}{m}\\lambda w) - \\alpha\\frac{2}{m}X^T(\\hat{y} - y) \\\\\n",
    "w := w(1 - \\alpha \\frac{2}{m}\\lambda) - \\alpha\\frac{2}{m}X^T(\\hat{y} - y)\n",
    "\\end{gather}\n",
    "\n",
    "$\\lambda$ 是由使用者決定的參數，當 $\\lambda = 0$ 時代表不抑制係數向量，沒有正規化效果；較大的 $\\lambda$ 會壓抑最適化係數向量的選擇，正規化效果大，藉此在配適不足與過度配適之間進行平衡，當正規化效果過大時，模型又會變得與配適不足的狀態相近。使用 Scikit-Learn 定義好的 `Ridge` 類別可以協助我們建構具備 L2 正規化效果的迴歸模型，正規化效果由 `alpha` 參數決定，愈大表示正規化效果愈強。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = player_stats['heightMeters'].values.astype(float).reshape(-1, 1)\n",
    "y = player_stats['weightKilograms'].values.astype(float)\n",
    "poly = PolynomialFeatures(9)\n",
    "X_plot = np.linspace(X.min() - 0.1, X.max().max() + 0.1).reshape(-1, 1)\n",
    "X_poly = poly.fit_transform(X)\n",
    "X_plot_poly = poly.fit_transform(X_plot)\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X_poly, y, test_size=0.33, random_state=42)\n",
    "alphas = [0, 1, 10, 1e3, 1e5, 1e6, 1e7, 1e8, 1e9]\n",
    "y_plots = []\n",
    "for alpha in alphas:\n",
    "    h = Ridge(alpha=alpha)\n",
    "    h.fit(X_train, y_train)\n",
    "    y_pred = h.predict(X_train)\n",
    "    y_pred = h.predict(X_plot_poly)\n",
    "    y_plots.append(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = X.ravel()\n",
    "fig, axes = plt.subplots(3, 3, figsize=(12, 6), sharey=True)\n",
    "for k, alpha, y_p in zip(range(9), alphas, y_plots):\n",
    "    i = k // 3\n",
    "    j = k % 3\n",
    "    x_p = X_plot.ravel()\n",
    "    axes[i, j].scatter(x, y, s=5, alpha=0.5)\n",
    "    axes[i, j].plot(x_p, y_p, color=\"red\")\n",
    "    axes[i, j].set_ylim(60, 150)\n",
    "    axes[i, j].set_title(\"L2 Regularization: {:.0f}\".format(alpha))\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同樣在類別預測任務於原本的誤差函式 $J(w)$ 也能夠加上 $\\lambda w^Tw$ 抑制係數向量。\n",
    "\n",
    "\\begin{equation}\n",
    "J(w) = \\frac{1}{m}(-ylog(\\sigma(Xw)) - (1-y)log(1-\\sigma(Xw)) + \\lambda w^Tw)\n",
    "\\end{equation}\n",
    "\n",
    "接著求解梯度：$J(w)$ 關於 $w$ 的偏微分。\n",
    "\n",
    "\\begin{align}\n",
    "\\frac{\\partial J}{\\partial w} &= \\frac{1}{m}(-y(1-\\sigma(Xw))X - (1-y)(-\\sigma(Xw)X) + 2\\lambda w) \\\\\n",
    "&=\\frac{1}{m}(-X^Ty + y\\sigma(Xw)X + X^T\\sigma(Xw) - y\\sigma(Xw)X + 2\\lambda w) \\\\\n",
    "&=\\frac{1}{m}(-X^Ty + X^T\\sigma(Xw) + 2\\lambda w) \\\\\n",
    "&=\\frac{1}{m}(X^T(\\sigma(Xw) - y) + 2\\lambda w) \\\\\n",
    "&=\\frac{1}{m}(X^T(\\sigma(Xw) - y) + \\frac{1}{C}w) \\text{, where } C=\\frac{1}{2\\lambda}\n",
    "\\end{align}\n",
    "\n",
    "就可以寫出具備 L2 正規化效果梯度遞減的式子。\n",
    "\n",
    "\\begin{gather}\n",
    "w := w - \\alpha \\frac{1}{m}(X^T(\\sigma(Xw) - y) + \\frac{1}{C}w) \\text{, where } C=\\frac{1}{2\\lambda} \\\\\n",
    "w := w - \\alpha \\frac{1}{mC}w - \\alpha \\frac{1}{m}(X^T(\\sigma(Xw) - y)) \\\\\n",
    "w := w(1 - \\alpha \\frac{1}{mC}) - \\alpha \\frac{1}{m}(X^T(\\sigma(Xw) - y))\n",
    "\\end{gather}\n",
    "\n",
    "Scikit-Learn 的 `LogisticRegression` 類別中的參數 `C` 與 L2 正規化 $\\lambda$ 參數是倒數關係 $C=\\frac{1}{2\\lambda}$，當 `C` 愈大表示正規化效果愈低，反之 `C` 愈小表示正規化效果愈高，這也是為什麼在類別預測的任務章節中，為了和自訂類別 `LogitReg` 比較需要設定一個很大的 `C` 來讓正規化效果降到很低。"
   ]
  },
  {
   "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. 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",
    "3. Best Practices for Model Evaluation and Hyperparameter Tuning. In: Sebastian Raschka, Vahid Mirjalili, Python Machine Learning (https://www.amazon.com/Python-Machine-Learning-scikit-learn-TensorFlow/dp/1789955750/)\n",
    "4. Confustion matrix (https://en.wikipedia.org/wiki/Confusion_matrix)\n",
    "5. Regularization (https://en.wikipedia.org/wiki/Regularization_(mathematics))"
   ]
  }
 ],
 "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
}