Week6/Fundamental24.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 여러가지 성능 평가 척도(Evaluation Metric)에 대해서\n",
    "\n",
    "<br/>\n",
    "\n",
    "> **context**\n",
    "1. [Loss와 Metric](#1.-Loss와-Metric)\n",
    "2. [Confusion Matrix와 Precision/Recall](#2.-Confusion-Matrix와-Precision/Recall)\n",
    "3. [Threshold의 변화에 따른 모델 성능](#3.-Threshold의-변화에-다른-모델-성능)\n",
    "4. [Precision-Recall 커브](#4.-Precision\\-Recall-커브)\n",
    "5. [ROC 커브](#5.-ROC-커브)\n",
    "6. [다양한 머신러닝 모델의 평가 척도](#6.-다양한-머신러닝-모델의-평가-척도)\n",
    "\n",
    "\n",
    "여러 머신러닝 모델을 만들다 보면, 모델의 학습 과정에서 **성능 평가**(evaluation)는 머신러닝 모델을 만드는 데 있어 필수적인 작업입니다. 올바른 성능 평가가 이루어져야 정확하게 모델의 완성도를 측정하고, 학습에 대한 평가를 끝낼 수 있다고 판단할 수 있기 때문입니다. \n",
    "\n",
    "각 머신러닝 문제는 서로 다른 **성능 평가 척도(Evaluation Metric)**를 가지며, 하나의 문제애 대해서도 목적에 따라 여러가지 척도를 사용할 수 있습니다.\n",
    "<br/>\n",
    "예를 들자면 분류(classification) 문제에서 accuracy뿐만 아니라 precision, recall 등을 사용하는 것이 있죠. \n",
    "\n",
    "- [scikit learn - 3.3. Metrics and scoring: quantifying the quality of predictions](https://scikit-learn.org/stable/modules/model_evaluation.html#multilabel-ranking-metrics)\n",
    "\n",
    "위는 사이킷런에서 제공하는 다양한 성능평가 척도들입니다. 대충 훑어만 봐도 꽤 많네요.\n",
    "\n",
    "\n",
    "머신러닝에는 분류(classification)말고도 회귀(Regression), 랭킹(Ranking), 군집(Clustering)등 다양한 모델이 존재하며, 딥러닝을 통해 이미지, 텍스트, 음성 등을 다루는 분야에서는 또 그에 따른 적합한 성능 평가 방식이 필요합니다.\n",
    "\n",
    "이번 시간에는 대표적인 성능평가 척도들에 대해서 알아봅시다!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Loss와 Metric\n",
    "\n",
    "Loss와 Metric의 차이는 무엇일까요? 예를들어 RMSE(Root Mean Squared Error)는 Loss함수로 사용되기도 하고 회귀 모델의 Metric으로 사용되기도 합니다. \n",
    "\n",
    "한번 그 답을 생각해보고 아래를 읽어봅시다. \n",
    "\n",
    "Loss와 Metric은 사용되는 시점과 용도가 다르다고 할 수 있습니다.\n",
    "\n",
    "- Loss : 모델 학습시 **학습 데이터(train data)**를 바탕으로 개선되어 모델의 파라미터 업데이트에 활용되는 함수\n",
    "- Metric : 모델 학습 종료 후 **테스트 데이터(test data)**를 바탕으로 계산되어 학습된 모델의 성능을 평가하는데 활용되는 함수\n",
    "\n",
    "MNIST 손글씨 분류모델을 생각해봅시다. 우리는 분류 모델의 Loss 함수로 Cross Entropy Loss를 사용했습니다. 학습된 모델을 평가하는 Metric으로는 Accuracy를 사용했었죠.\n",
    "\n",
    "왜 굳이 Loss와 Metric을 다르게 적용했을까요? \n",
    "\n",
    "그 답은 바로 이산성과 연속성에 있습니다. Discrete한 Accuracy는 Continuous한 Cross Entropy에 비해 파라미터가 학습되어야 할 방향을 정확하게 제시하지 못합니다. 우리가 궁극적으로 원하는 모델은 테스트 데이터에 대한 Accuracy가 높은 모델이지, Cross Entropy가 얼마나 낮아졌는지는 궁극적인 관심은 아닙니다. 하지만 모델의 정확성을 향상시켜 더 Accuracy가 높은 모델을 만들기 위해서는 Cross Entropy가 적당한 Loss 함수가 될 것입니다.\n",
    "\n",
    "아래 글은 참고할만한 글입니다. 한번 읽어보고 넘어갑시다 :)\n",
    "\n",
    "- [Loss vs. Metric](https://deepestdocs.readthedocs.io/en/latest/002_deep_learning_part_1/0023/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Confusion Matrix와 Precision/Recall\n",
    "\n",
    "분류 모델에서는 다양한 성능평가 척도가 있습니다. 아래 친숙한 그림을 한번 봐볼까요?\n",
    "\n",
    "![img](./data/img.png)\n",
    "\n",
    "- True Positive(TP) : 모델이 양성(Positive)을 양성으로 맞혔을 때\n",
    "- True Negative(TN) : 모델이 음성(Negative)을 음성으로 맞혔을 때\n",
    "- False Positive(FP) : 모델이 음성(Neagtive)를 양성으로 잘못 예측했을 때\n",
    "- False Negative(FN) : 모델이 양성을 음성으로 잘못 예측했을 때\n",
    "\n",
    "그러면 분류 모델 측면에서 우리가 아는 **정확도(Accuracy)** 는 전체 표본 중 정확히 분류된 표본의 수 라고 볼 수 있습니다. 즉, 이진 분류일 때 정확도를 아래의 식으로 표현할 수 있습니다.\n",
    "\n",
    "$$정확도(Accuracy) = \\frac{TP+TN}{TP+TN+FP+FN}$$\n",
    "\n",
    "멀티 클래스(multi-class)의 분류 결과를 하고 있다면, 표본의 결과를 정답, 오답으로 나누어\n",
    "\n",
    "\n",
    "$$(정확도) = \\frac{ (정답을~맞힌~예측의~수)} { (전체~문제의~수)} = \\frac {TP+TN} {TP+TN+FP+FN}$$\n",
    "\n",
    "로 계산할 수 있습니다.\n",
    "\n",
    "### Precision과 Recall\n",
    "\n",
    "모델의 정확도와 함께 언급되는 것이 있습니다. 바로 Precision과 Recall인데요, Precision은 정밀도, Recall은 재현율이라는 단어로 표시합니다.\n",
    "\n",
    "\n",
    "![img](./data/img2.png)\n",
    "\n",
    "위에서 언급된 암환자 예측 모델 사례를 다시 생각해 봅시다. 정확도(Accuracy) 대신 정밀도(Precision) 개념은 다음과 같이 정의됩니다.\n",
    "\n",
    "$$ 정밀도(Precision) = \\frac {TP} {TP+FP} $$\n",
    "\n",
    "이 개념은 모델이 양성으로 규정한 것이 얼마나 정확한지를 보고싶을 때 사용합니다. 즉, 모델이 양성으로 잘못 규정한것이 적을수록 정밀도는 올라갑니다. \n",
    "\n",
    "재현율은 다음과 같이 정의됩니다.\n",
    "\n",
    "$$ 재현율(Recall) = \\frac {TP} {TP+FN} $$\n",
    "\n",
    "이 개념은 실제로 양성이 것들이 얼마나 모델에 의해 정확하게 탐지되었나를 보고 싶은 것입니다. 실제로 음성인 것을 양성으로 잘못 규정한 것에 대해서는 관심이 없습니다. 재현율이 높다는 것은 FN이 낮다는 것입니다. 즉 모델이 실제 양성을 분류해 내지 못한 경우가 적을 수록 재현율은 올라갑니다.\n",
    "\n",
    "\n",
    "모델을 생각해보면, 정확도가 높아도 precision이나 recall에서 낮은 점수가 나올 수 있습니다. 예를들어 confusion matrix의 4가지 카테고리 중 대부분이 TN에 몰려있다면 정확도는 높지만, 다른 성능평가 척도에서는 낮게 나올 수 있죠.\n",
    "\n",
    "여기서 결론을 내릴 수 있습니다. 음성 대 양성 데이터 분포가 불균형할 경우 정확도는 모델을 평가하는데 좋은 척도가 되지 못합니다. 그렇다면 이런 불균형 데이터가 주어진 상황에서 분류 모델을 어떻게 평가하면 좋을까요?\n",
    "\n",
    "### F-score\n",
    "\n",
    "위에서 본 Precision과 Recall은 단독으로 평가 척도로 사용하기에 부족한 면이 있습니다.\n",
    "\n",
    "예를 들어, Precision이 좋은 척도가 될만 한 스팸메일 분류기 모델을 생각해 봅시다. 이 경우에 FN은 다소 허용할만 합니다. 스팸이 잘못 걸러져 메일함이 들어오긴 했지만 FP가 발생할 경우에는 꼭 필요한 비지니스 메일이 스팸함에 버려 엄청난 손실이 발생하게 될지도 모릅니다. 그래서 FP를 줄이려면 애매한 메일을 음성으로 판단하는 게 좋은데, 그렇다고 해서 FN을 무한히 허용하면 스팸 메일 분류기 자체가 쓸모없어지는 상황이 될 수 있어 좋지 않습니다.\n",
    "\n",
    "Recall이 좋은 척도가 될만한 사례는 위의 암환자 예측 모델이 적당할 것 같습니다. 암 의심환자를 음성으로 분류했다가 환자의 생명을 위험에 빠뜨리게 되면 안되므로, FN을 최소화하는 Recall이 좋은 척도가 될 수 있을지도 모릅니다. 하지만 여기는 함정이 있습니다. Recall을 최대화하는 방법은 간단합니다. 모든 환자를 양성으로 진단해 버리면 됩니다. 적어도 FN이 발생하게 되지는 않으니 Recall은 무조건 1이 됩니다. 그러나 이런 예측모델 또한 쓸모가 없긴 마찬가지입니다.\n",
    "\n",
    "Precision과 Recall이라는 용어가 익숙하다면, 아마도 F1 score라는 개념도 익숙하실 것입니다. 이 개념은 아래의 F score에서 $\\beta$가 1이 될 때를 말합니다. F1 score는 Precision과 Recall의 **조화평균**이 되는 값으로서, Precision과 Recall 둘 다 고려할 수 있어서 분류 모델의 훌륭한 척도가 됩니다.\n",
    "\n",
    "$$F_\\beta = (1 + \\beta^2) \\cdot \\frac{\\mathrm{precision} \\cdot \\mathrm{recall}}{(\\beta^2 \\cdot \\mathrm{precision}) + \\mathrm{recall}}$$\n",
    "\n",
    "recall을 중요시 하고싶다면 beta값을 1보다 크게하고, precision을 중요하게 생각하고 싶다면 beta 크기를 줄여주는 형식으로 F-Score를 구하면 도움이 됩니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Threshold의 변화에 다른 모델 성능\n",
    "\n",
    "Threshold는 일정 이상 기준선이라고 생각하시면 됩니다. 앞서 우리는 recall과 Precision을 살펴보았죠. 이때 양성일 확률을 0.5가 넘으면 양성으로 분류하는 것이 아니라 양성일 확률이 0.3만 넘어도 양성으로 분류하도록 하면 어떨까요? 당연히 confusion matrix의 값들이 달라질 것입니다.\n",
    "\n",
    "이것은, 모델의 성능이라는 것이 F1 score같은 숫자 하나로만 규정될 수 있는 게 아니라는 것을 의미하게 됩니다. (물론 모델 출력의 해석방식이 고정적으로 주어진다면 F1 score는 유효한 Metric이 됩니다.) 이렇게 Threshold가 달라지는 것을 고려하여 전체적인 모델의 성능을 평가하는 방법으로 **PR(Precision and Recall) 커브**와 **ROC(Receiver Operating Characteristic) 커브**를 그려보는 두가지 방법이 있습니다.\n",
    "\n",
    "Threshold의 변화에 따라 모델 성능이 달라지는 상황을 간단한 분류 모델 예제를 통해 살펴 봅시다.\n",
    "\n",
    "#### 실습에 사용할 데이터 준비\n",
    "\n",
    "실습에 사용하기위해 사이킷런에서 제공하는 붓꽃 데이터를 가져오도록 하겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "\n",
    "iris = datasets.load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "print(X.shape)  # 4개의 feature를 가진 150개의 데이터입니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task의 재구성\n",
    "\n",
    "붓꽃 분류 예제는 상당히 간단하기 때문에, 그대로 훈련시키면 거의 100%에 가까운 성능을 냅니다. 성능 평가를 공부하는 지금으로서는 조금 재미가 없겠지요?\n",
    "\n",
    "일부러 데이터에 잡음(noise)을 추가해 성능을 낮추어 보겠습니다. 랜덤한 값으로 이루어진 `200 * n_features`, 즉 800개의 컬럼을 매 데이터마다 추가합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 804)\n"
     ]
    }
   ],
   "source": [
    "random_state = np.random.RandomState(0)\n",
    "n_samples, n_features = X.shape\n",
    "X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]\n",
    "\n",
    "print(X.shape)  # 804개의 feature를 가진 150개의 데이터가 되었습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "원래 붓꽃의 데이터는 총 3가지의 라벨로 나뉩니다.\n",
    "하지만 분석을 간단히 하기 위해 여기서는 양성/음성으로 나뉘는 이진 분류(binary classification) 문제로 줄여, 2개의 라벨 간 분류만 해보겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "훈련, 테스트 셋에 사용된 라벨의 종류: {0, 1} \n",
      "훈련 데이터 shape   : (50, 804)\n",
      "테스트 데이터 shape : (50, 804)\n"
     ]
    }
   ],
   "source": [
    "#- 0, 1 라벨에 속하는 붓꽃 샘플만 사용하도록 제한합니다.\n",
    "X_train, X_test, y_train, y_test = train_test_split(X[y < 2], y[y < 2],\n",
    "                                                    test_size=.5,\n",
    "                                                    random_state=random_state)\n",
    "\n",
    "print(\"훈련, 테스트 셋에 사용된 라벨의 종류: {} \".format( set(y_test)))\n",
    "print(\"훈련 데이터 shape   :\", X_train.shape)\n",
    "print(\"테스트 데이터 shape :\", X_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 모델 학습\n",
    "\n",
    "2개의 라벨로 나뉜 데이터를 가지고, SVM(Support Vector Machine)으로 모델을 구성하여 학습시킨 후 test 데이터를 넣어 정확도를 확인해보도록 하겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.48"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "\n",
    "classifier = svm.SVC(kernel='poly', random_state=random_state)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "classifier.score(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`classifier.score()` 함수는 테스트데이터에 대한 평균 정확도(Accuracy)를 리턴합니다. 0.5에 가까운 수준의 binary classifier라니, 전혀 분류 성능이 없다고 봐야겠군요. 이번에는 SVM의 커널을 바꾸어 보겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier = svm.SVC(kernel='linear', random_state=random_state)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "classifier.score(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이번에는 80% 정도의 정확도가 나왔습니다. SVM은 아주 복잡하면서도 아름다운 수학적 배경을 갖춘 분류모델로 알려져 있습니다. SVM 자체를 이해하는 것은 오늘의 범위를 넘어서기 때문에 일단은 SVM 모델의 성능을 평가하는 데 집중하도록 하겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0,\n",
       "       0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1,\n",
       "       0, 1, 1, 1, 0, 1])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0,\n",
       "       0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1,\n",
       "       0, 1, 1, 0, 1, 0])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`classifier.predict()` 리턴값과 y_test를 비교해 보았습니다. 모델 뒤에 Softmax가 있어서 확률값을 출력하는 Logistic Regression 모델과는 달리, SVM에서 별도로 제공하는 `decision_function()` 함수가 존재합니다. 이 함수값은 (-1, 1) 범위값을 가지는데, 0보다 작으면 음성(label=0), 0보다 크면 양성(label=1)으로 분류하게 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.29512751  0.28798352  0.17635465  0.19056886  0.38391605 -0.30841065\n",
      " -0.10084254 -0.23481309  0.18576987 -0.36011033 -0.15726747 -0.25714889\n",
      " -0.14979669  0.02063898  0.04509171 -0.17239443  0.07287957 -0.0689103\n",
      " -0.13452462 -0.30697712  0.25404241 -0.28916471 -0.52061453  0.25252233\n",
      "  0.02177777 -0.10980907  0.37468422  0.35303004 -0.6211302  -0.42920064\n",
      " -0.14770647  0.00593404 -0.34735296  0.32245409 -0.19439024  0.1288847\n",
      " -0.0320947  -0.23008604 -0.10135548 -0.46962186  0.05184235  0.0609688\n",
      "  0.05632596  0.44769206 -0.38804349  0.24704844  0.16063684  0.0144203\n",
      " -0.03136574  0.11179177]\n"
     ]
    }
   ],
   "source": [
    "y_score = classifier.decision_function(X_test)\n",
    "print(y_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그럼 여기서 **confusion_matrix**를 계산해 보겠습니다. 실제 정답값 y_test와 y_pred를 비교해 보면 다음과 같은 결과가 얻어집니다. confusion_matrix는 `[[TP, FN], [FP, TN]]`의 형태로 출력됩니다. 사이킷런에서는 `classification_report`이라는 함수를 통해 confusion_matrix에서 얻어진 TP, FN, FP, TN 값을 토대로 Precision, Recall, F1-score 등의 평가척도값을 계산해 줍니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[20  4]\n",
      " [ 6 20]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.77      0.83      0.80        24\n",
      "           1       0.83      0.77      0.80        26\n",
      "\n",
      "    accuracy                           0.80        50\n",
      "   macro avg       0.80      0.80      0.80        50\n",
      "weighted avg       0.80      0.80      0.80        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "y_pred = classifier.predict(X_test)\n",
    "conf_mat = confusion_matrix(y_test, y_pred)\n",
    "print(conf_mat)\n",
    "rpt_result = classification_report(y_test, y_pred)\n",
    "print(rpt_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "방금 우리는 `decision_function` 값이 0보다 큰 것을 양성으로 분류했습니다. 만약 양성 분류 기준을 좀더 확대해서 -0.1보다 큰 것을 양성으로 분류한다면 어떻게 될까요?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[18  6]\n",
      " [ 5 21]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.78      0.75      0.77        24\n",
      "           1       0.78      0.81      0.79        26\n",
      "\n",
      "    accuracy                           0.78        50\n",
      "   macro avg       0.78      0.78      0.78        50\n",
      "weighted avg       0.78      0.78      0.78        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_pred_new_threshold = classifier.decision_function(X_test) > -0.1\n",
    "conf_mat = confusion_matrix(y_test, y_pred_new_threshold)\n",
    "print(conf_mat)\n",
    "rpt_result = classification_report(y_test, y_pred_new_threshold)\n",
    "print(rpt_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "어떻습니까? 양성 분류 기준을 확대했기 때문에, Recall이 0.77에서 0.81로 상승했습니다. 하지만 전체적인 F1-score는 0.80에서 0.79로 소폭 하락했습니다. 하지만 태스크의 특성에 따라서는 이것이 오히려 더 좋은 결과를 가져올지도 모르겠습니다.\n",
    "\n",
    "Threshold 값을 조금씩 바꿔보면서 평가척도값이 어떻게 변하는지 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12 12]\n",
      " [ 2 24]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.86      0.50      0.63        24\n",
      "           1       0.67      0.92      0.77        26\n",
      "\n",
      "    accuracy                           0.72        50\n",
      "   macro avg       0.76      0.71      0.70        50\n",
      "weighted avg       0.76      0.72      0.71        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_pred_new_threshold = classifier.decision_function(X_test) > -0.2\n",
    "conf_mat = confusion_matrix(y_test, y_pred_new_threshold)\n",
    "print(conf_mat)\n",
    "rpt_result = classification_report(y_test, y_pred_new_threshold)\n",
    "print(rpt_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[23  1]\n",
      " [12 14]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.66      0.96      0.78        24\n",
      "           1       0.93      0.54      0.68        26\n",
      "\n",
      "    accuracy                           0.74        50\n",
      "   macro avg       0.80      0.75      0.73        50\n",
      "weighted avg       0.80      0.74      0.73        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_pred_new_threshold = classifier.decision_function(X_test) > 0.1\n",
    "conf_mat = confusion_matrix(y_test, y_pred_new_threshold)\n",
    "print(conf_mat)\n",
    "rpt_result = classification_report(y_test, y_pred_new_threshold)\n",
    "print(rpt_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24  0]\n",
      " [17  9]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.59      1.00      0.74        24\n",
      "           1       1.00      0.35      0.51        26\n",
      "\n",
      "    accuracy                           0.66        50\n",
      "   macro avg       0.79      0.67      0.63        50\n",
      "weighted avg       0.80      0.66      0.62        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_pred_new_threshold = classifier.decision_function(X_test) > 0.2\n",
    "conf_mat = confusion_matrix(y_test, y_pred_new_threshold)\n",
    "print(conf_mat)\n",
    "rpt_result = classification_report(y_test, y_pred_new_threshold)\n",
    "print(rpt_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "값이 계속 조금씩 달라집니다. 이렇게 우리는 confusion matrix를 만들기 전에 threshold를 설정할 수 있습니다.\n",
    "\n",
    "## 4. Precision-Recall 커브\n",
    "\n",
    "동일한 모델이어도 Threshold 값에 따라 Precision, Recall 값이 변하는 것을 위에서 확인했습니다. **PR(Precision-Recall)커브**는 Recall을 x축, Precision을 y축으로 놓고 Threshold 변화에 따른 두 값의 변화를 그래프로 그린 것입니다.\n",
    "\n",
    "한번 그려봅시다. PR커브는 사이킷런에 내장되어있는 함수기도 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'binary class Precision-Recall curve: AP=0.91')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import plot_precision_recall_curve\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "disp = plot_precision_recall_curve(classifier, X_test, y_test)\n",
    "disp.ax_.set_title('binary class Precision-Recall curve: '\n",
    "                   'AP={0:0.2f}'.format(average_precision))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위 그림을 보면 Precision과 Recall 사이의 트레이드오프 관계를 확인할 수 있습니다. Threshold값에 따라 우리가 얻게 되는 Precision, Recall 값은 저 그래프상의 어딘가가 될 것입니다. 물론 우리가 원하는 값은 Precision이든 Recall이든 모두 1에 가깝기를 원합니다. 이상적으로는 그래프가 (1, 1)에 찍히면 좋겠습니다만, 가급적 위 그래프가 (1, 1)에 근접하도록 그려지길 바랍니다.\n",
    "\n",
    "그래서 Threshold 값에 무관하게 모델의 전체적인 성능을 평가하는 방법으로, 위 PR 커브 아래쪽 면적을 계산하는 방법이 있습니다. 이것을 AUC(Area Under Curve) 값이라고 합니다. PR AUC를 계산하는 방법으로 다음과 같이 사이킷런에서 제공하는 `average_precision_score` 함수를 사용합니다.\n",
    "\n",
    "$$\\text{AP} = \\sum_n (R_n - R_{n-1}) P_n$$\n",
    "\n",
    "위 수식의 특성을 살펴보면, `average_precision_score(AP)` 값은, n 값을 무한히 크게 한다면 아주 작은 Recall 구간에 대해 Pn 값을 적분하는 것과 같게 됩니다. 그러므로 PR 커브의 아래쪽 면적인 `PR AUC`와 같은 의미가 되겠군요. 하지만 사이킷런 문서에서는 `average_precision_score`와 `PR AUC`가 구현 측면에서 약간 다르다고 설명하고 있습니다. 두 개념이 의미적으로 비슷하게 사용될 수 있다고만 이해하면 될 것 같습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "평균 precision-recall score: 0.91\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import average_precision_score\n",
    "average_precision = average_precision_score(y_test, y_score)\n",
    "\n",
    "print('평균 precision-recall score: {0:0.2f}'.format(\n",
    "      average_precision))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`average_precision_score` 값은 최대 1이 될 수 있을 것입니다. 위에서는 0.91이 나왔군요. 그렇다면 모델을 바꿔 보면 이 값이 어떻게 달라질지 궁금해집니다. 우리는 위에서 SVM의 커널을 'poly'로 주었을 때 Accuracy가 매우 낮았던 것을 기억합니다. 이때의 averageprecisionscore 값이 어떻게 될지 직접 구현해서 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "평균 precision-recall score: 0.90\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import average_precision_score\n",
    "\n",
    "classifier = svm.SVC(kernel='poly', random_state=random_state)\n",
    "classifier.fit(X_train, y_train)\n",
    "y_score = classifier.decision_function(X_test)\n",
    "average_precision = average_precision_score(y_test, y_score)\n",
    "\n",
    "print('평균 precision-recall score: {0:0.2f}'.format(\n",
    "      average_precision))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'binary class Precision-Recall curve: AP=0.90')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "disp = plot_precision_recall_curve(classifier, X_test, y_test)\n",
    "disp.ax_.set_title('binary class Precision-Recall curve: '\n",
    "                   'AP={0:0.2f}'.format(average_precision))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. ROC 커브\n",
    "\n",
    "**ROC(Receiver Operating Characteristic Curve)** 는 수신자 조작 특성 곡선이라는 단어로 표현할 수 있습니다.\n",
    "ROC는 앞서 계산해보았던 **Confusion Matrix** 수치를 활용해, 분류기의 분류 능력을 그래프로 표현하는 방법입니다. 물론 이 그래프도 PR 커브와 마찬가지로 분류기의 Threshold 값의 변화에 따라 Confusion Matrix에 생기는 변화로 인해 그려지는 것입니다.\n",
    "\n",
    "### ROC 예시 곡선\n",
    "\n",
    "ROC를 그리는 축인 TP Rate과 FP Rate은 Precision, Recall과 비슷해 보이지만 조금 다른 개념입니다.\n",
    "\n",
    "TP Rate과 FP Rate은 다음과 같이 계산합니다.\n",
    "\n",
    "$$TPR (Sensitivity) = \\frac {TP} {TP + FN}$$\n",
    "\n",
    "$$FPR (1-Specificity) = \\frac {FP} {TN + FP}$$\n",
    "\n",
    "![img](./data/img3.png)\n",
    "\n",
    "위 그림은 ROC 그래프의 예시이며, 점선이 ROC 입니다.\n",
    "\n",
    "TP Rate(TPR)의 수식을 잘 보면 실은 우리가 잘 아는 Recall과 같은 것입니다. FP Rate는 `1-Specificity`라고 소개되어 있는데, Specificity라는 것은 $\\frac {TN} {TN + FP}$ 이 되므로, 실은 음성 샘플에 대한 Recall이라고 볼 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### AUC 예시 영역\n",
    "\n",
    "![IMG](./data/img4.png)\n",
    "\n",
    "위 그림은 **ROC AUC(Area Under the ROC Curve)** 를 보여주는 회색 영역으로, 저 영역의 넓이가 넓은 모델일수록, 상대적으로 좋은 성능을 보여준다고 합니다. 하지만 PR 커브만큼 직관적으로 와닿지 않아서, 왜 그런 것인지 얼른 와닿지 않습니다. 그렇다면 일단 한번 그려 보겠습니다. 사이킷런에는 `roc_curve`, `auc` 라는 함수를 통해 ROC를 그리거나 ROC AUC를 쉽게 구해볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "fpr, tpr, _ = roc_curve(y_test, y_score)\n",
    "roc_auc = auc(fpr, tpr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "auc result:0.8605769230769231\n"
     ]
    }
   ],
   "source": [
    "plt.figure()\n",
    "lw = 2\n",
    "plt.plot(fpr, tpr, color='darkorange',\n",
    "         lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver operating characteristic example')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n",
    "print(f\"auc result:{roc_auc}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "아주 이상적으로 Precision과 Recall이 전부 1이 되는 완벽한 모델이라면 ROC 커브에서는 어디에 점이 찍힐까요? 네, 바로 (0, 1)일 것입니다. 양성과 음성에 대한 Recall이 모두 1이 될 테니 TPR은 1, FPR은 0이 될 것입니다.\n",
    "\n",
    "몇가지 극단적인 경우를 생각해 봅시다. 모델이 모든 샘플에 대해 양성이라고 분류한다면 어떨까요? 이땐 이 분류기가 (1, 1)에 찍힐 것입니다. 반대로 모든 샘플에 대해 음성이라고 분류한다면 이 분류기는 (0, 0)에 찍힐 것입니다. 이번엔 완벽한 랜덤 분류기를 가정해 봅시다. 이 분류기는 양성이든 음성이든 무관하게 p의 확률로 양성이라고 분류할 것입니다. 이 랜덤분류기의 Recall은 p가 될 것입니다. 음성에 대한 Recall도 p가 될 테니 이 분류기는 (p, 1-p)에 찍힐 것입니다.\n",
    "\n",
    "위 그래프에서 (0, 0)과 (1, 1)을 잇는 파란 점선은 바로 위와 같은 극단적인 경우들만 모아놓은 경우입니다. 그래서 의미있는 분류기라면 적어도 이 파란 점선보다는 위쪽에 그려져야 하며, 가급적 (0, 1)에 가깝게 그려질 수록 우수한 분류기가 됩니다. 그러므로 ROC AUC가 클수록 상대적으로 좋은 성능의 모델이라고 할 수 있을 것입니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 다양한 머신러닝 모델의 평가 척도\n",
    "\n",
    "지금까지 다양한 분류 모델의 평가 척도에 대해서 알아보았습니다. 분류 문제에 있어 문제의 성격, 분류 기준 등 다양한 변수에 따라 정확한 모델 평가 척도는 달라질 수 있어 다소 복잡했습니다. 하지만 머신러닝에는 분류만 있는 것이 아니라 회귀, 추천, 군집 등 다양한 모델이 있습니다. 음성, 이미지, 텍스트 등의 생성형 모델들이 가지는 독특한 평가 척도들도 매우 다양합니다.\n",
    "\n",
    "이번 시간에는 간단히 무엇이 있는지만 확인해봅시다.\n",
    "\n",
    "### 회귀 모델의 평가 척도\n",
    "\n",
    "회귀 모델은 분류 모델에 비해 평가 척도를 다루는 것이 간단합니다. Loss 함수가 테스트 셋에 적용되는 것이 그대로 Metric가 되는 경우가 대부분입니다. \n",
    "\n",
    "회귀 모델의 평가 척도는 다양하게 있습니다. 아래 글에서 자세히 확인할 수 있습니다.\n",
    "\n",
    "- [회귀의 오류 지표 알아보기](https://partrita.github.io/posts/regression-error/)\n",
    "\n",
    "### 랭킹 모델의 평가 척도\n",
    "\n",
    "추천 시스템은 넓게 보면 정보 검색 (information retrieval)과 같은 로직을 가지고 있습니다. 이런 모델들이 일반적인 분류 모델과 다른 점은, `랭킹(우선순위)` 개념이 추가된다는 점입니다. User를 입력으로 했을 때, item들이 추천할만한지 여부를 분류만 하는 것이 아니라 얼마나 추천할만한지 랭킹까지 매겨야 한다는 점입니다.\n",
    "\n",
    "랭킹 모델의 평가 척도에 대한 아래 글을 읽어봅시다.\n",
    "\n",
    "- [정보 검색(Information Retrieval) 평가는 어떻게 하는 것이 좋을까?(2/2)](https://lamttic.github.io/2020/03/20/01.html)\n",
    "\n",
    "- MRR(Mean Reciprocal Rank)\n",
    "    1. 각 사용자마다 제공한 추천 컨텐츠 중 관련있는 컨텐츠의 가장 높은 위치를 역수로 계산한다.\n",
    "    2. 사용자마다 계산된 점수를 모아 평균을 계산한다.\n",
    "- MAP(Mean Average Precision)\n",
    "    1. 각 사용자마다 관련된 컨텐츠를 구하여 해당 관련 컨텐츠 위치까지의 모든 목록(sublist)에 대하여 정밀도를 계산한다.\n",
    "    2. 계산된 정밀도 값들에 대하여 사용자별로 평균을 내고, 그 결과를 모두 모아 평균을 계산한다.\n",
    "- NDCG(Normalized Discounted Cumulative Gain)\n",
    "    1. 모든 추천 컨첸츠들의 관련도를 합하여 CG(Cumulative gain)을 구한다.\n",
    "    2. CG에서 추천 컨텐츠들의 관련도를 합하였다면 DCG는 각 추천 컨텐츠의 관련도를 Log 함수로 나누어 값을 구한다. log 함수 특성상 위치 값이 클수록 DCG의 값을 더 작아지게 함으로써 상위 컨텐츠의 값을 점수에 더 반영할 수 있게 한다.\n",
    "    3. DCG 값에 관련도를 더 강조하고 싶다면, $2^관련도 - 1$과 같이 관련도의 영향을 증가시킬 수 있다.\n",
    "    4. 사용자마다 제공되는 추천 컨텐츠의 DCG와는 별개로 IDCG(이상적인 DCG)를 미리 계산해놓는다.\n",
    "    5. 각 사용자의 DCG를 IDCG로 나누어서 사용자별 NDCG를 구한다.\n",
    "    6. 사용자별 NDCG의 평균을 구하여 해당 IR의 NDCG를 구한다.\n",
    "\n",
    "\n",
    "### 이미지 생성 모델의 평가 척도\n",
    "\n",
    "모델을 평가한다는 것은 결국 정답과 예측치 사이의 거리를 측정하는 방식입니다. 그런데 이미지 생성 모델에서 원본 이미지와 새로운 이미지 사이의 거리를 어떻게 측정할 수 있을까요?\n",
    "\n",
    "아래 글에서는 세가지 방법이 있다고 합니다. MSE, PSNR, SSIM인데요, 아래 글에서 한번 직접 확인해보세요.\n",
    "\n",
    "- [A Quick Overview of Methods to Measure the Similarity Between Images](https://medium.com/@datamonsters/a-quick-overview-of-methods-to-measure-the-similarity-between-images-f907166694ee)\n",
    "\n",
    "\n",
    "### 기계 번역 모델의 평가 척도\n",
    "\n",
    "이미지 생성모델에서 원본과 생성본을 비교하여 거리를 잰다는 것은 까다롭긴 하지만 RGB 공간 등 두 이미지 사이의 거리를 측정할 수 있는 개념적 공간이 존재합니다. 그러나 텍스트라면 어떨까요? 텍스트 생성 모델 중 가장 대중적인 것은 기계번역 모델입니다. 영어를 한국어로 번역한 문장이 정답 한국어와 얼마나 비슷한지를 어떻게 측정하면 좋을까요?\n",
    "\n",
    "기계번역 모델의 평가척도에 대한 아래 글을 읽어봅시다.\n",
    "\n",
    "- [BLEU Score](https://donghwa-kim.github.io/BLEU.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style> .container{width:90% !important;}</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "\n",
    "display(HTML(\"<style> .container{width:90% !important;}</style>\"))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "aiffel",
   "language": "python",
   "name": "aiffel"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}