3_Evaluation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## 정확도"
      ],
      "metadata": {
        "id": "mlcjIWVvuIh5"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "F4piUQG5NSVg"
      },
      "outputs": [],
      "source": [
        "from sklearn.base import BaseEstimator"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class MyDummyClassifier(BaseEstimator):\n",
        "  def fit(self,X, y=None):\n",
        "    pass\n",
        "  def predict(self, X):\n",
        "    pred = np.zeros((X.shape[0]))\n",
        "    for i in range (X.shape[0]):\n",
        "      if X['Sex'].iloc[i] == 1:\n",
        "        pred[i] = 0\n",
        "      else:\n",
        "        pred[i] = 1\n",
        "\n",
        "    return pred"
      ],
      "metadata": {
        "id": "yXiZpj5mNbLF"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "\n",
        "def fillna(df):\n",
        "    df['Age'].fillna(df['Age'].mean(), inplace=True)\n",
        "    df['Cabin'].fillna('N', inplace=True)\n",
        "    df['Embarked'].fillna('N', inplace=True)\n",
        "    df['Fare'].fillna(0, inplace=True)\n",
        "    return df\n",
        "\n",
        "def drop_features(df):\n",
        "    df.drop(['PassengerId', 'Name', 'Ticket'], axis=1, inplace=True)\n",
        "    return df\n",
        "\n",
        "def format_features(df):\n",
        "    df['Cabin'] = df['Cabin'].str[:1]\n",
        "    features = ['Cabin', 'Sex', 'Embarked']\n",
        "    for feature in features:\n",
        "        le = LabelEncoder()\n",
        "        le = le.fit(df[feature])\n",
        "        df[feature] = le.transform(df[feature])\n",
        "    return df\n",
        "\n",
        "def transform_features(df):\n",
        "    df = fillna(df)\n",
        "    df = drop_features(df)\n",
        "    df = format_features(df)\n",
        "    return df"
      ],
      "metadata": {
        "id": "sETx5TImSROE"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "titanic_df = pd.read_csv(r'/content/drive/MyDrive/CUAI/titanic.csv')\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "y_titanic_df = titanic_df['Survived']\n",
        "X_titanic_df= titanic_df.drop('Survived', axis=1)\n",
        "X_titanic_df = transform_features(X_titanic_df)\n",
        "X_train, X_test, y_train, y_test=train_test_split(X_titanic_df, y_titanic_df,\n",
        "                                                  test_size=0.2, random_state=0)\n",
        "\n",
        "# 위에서 생성한 Dummy Classifier를 이용해 학습/예측/평가 수행.\n",
        "myclf = MyDummyClassifier()\n",
        "myclf.fit(X_train, y_train)\n",
        "\n",
        "mypredictions = myclf.predict(X_test)\n",
        "print('Dummy Classifier의 정확도는: {0:.4f}'.format(accuracy_score(y_test, mypredictions)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VHPpcilZP9ou",
        "outputId": "d921d5e5-feba-4893-bcbc-5c3dace4af80"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n",
            "Dummy Classifier의 정확도는: 0.7877\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.datasets import load_digits\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.base import BaseEstimator\n",
        "from sklearn.metrics import accuracy_score\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "class MyFakeClassifier(BaseEstimator):\n",
        "    def fit(self,X,y):\n",
        "        pass\n",
        "\n",
        "    # 입력값으로 들어오는 X 데이터 셋의 크기만큼 모두 0값으로 만들어서 반환\n",
        "    def predict(self,X):\n",
        "        return np.zeros( (len(X), 1) , dtype=bool)\n",
        "\n",
        "# 사이킷런의 내장 데이터 셋인 load_digits( )를 이용하여 MNIST 데이터 로딩\n",
        "digits = load_digits()\n",
        "\n",
        "print(digits.data)\n",
        "print(\"### digits.data.shape:\", digits.data.shape)\n",
        "print(digits.target)\n",
        "print(\"### digits.target.shape:\", digits.target.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8-bdIBprQLb9",
        "outputId": "53853ffb-3484-42c4-c53e-77a3db4a0fa8"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 0.  0.  5. ...  0.  0.  0.]\n",
            " [ 0.  0.  0. ... 10.  0.  0.]\n",
            " [ 0.  0.  0. ... 16.  9.  0.]\n",
            " ...\n",
            " [ 0.  0.  1. ...  6.  0.  0.]\n",
            " [ 0.  0.  2. ... 12.  0.  0.]\n",
            " [ 0.  0. 10. ... 12.  1.  0.]]\n",
            "### digits.data.shape: (1797, 64)\n",
            "[0 1 2 ... 8 9 8]\n",
            "### digits.target.shape: (1797,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# digits번호가 7번이면 True이고 이를 astype(int)로 1로 변환, 7번이 아니면 False이고 0으로 변환.\n",
        "y = (digits.target == 7).astype(int)\n",
        "X_train, X_test, y_train, y_test = train_test_split( digits.data, y, random_state=11)"
      ],
      "metadata": {
        "id": "qiXGbn5_UkwO"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 불균형한 레이블 데이터 분포도 확인.\n",
        "print('레이블 테스트 세트 크기 :', y_test.shape)\n",
        "print('테스트 세트 레이블 0 과 1의 분포도')\n",
        "print(pd.Series(y_test).value_counts())\n",
        "\n",
        "# Dummy Classifier로 학습/예측/정확도 평가\n",
        "fakeclf = MyFakeClassifier()\n",
        "fakeclf.fit(X_train , y_train)\n",
        "fakepred = fakeclf.predict(X_test)\n",
        "print('모든 예측을 0으로 하여도 정확도는:{:.3f}'.format(accuracy_score(y_test , fakepred)))"
      ],
      "metadata": {
        "id": "HcsL2TDKVAlF",
        "outputId": "489b2741-6623-43e2-fdac-344fbec0cad0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "레이블 테스트 세트 크기 : (450,)\n",
            "테스트 세트 레이블 0 과 1의 분포도\n",
            "0    405\n",
            "1     45\n",
            "dtype: int64\n",
            "모든 예측을 0으로 하여도 정확도는:0.900\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 오차행렬"
      ],
      "metadata": {
        "id": "3XWLw0TIuPke"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "confusion_matrix(y_test, fakepred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6L5pxemT2OqE",
        "outputId": "766f6d19-5c16-4d7e-caff-9a80e66ff3b7"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[405,   0],\n",
              "       [ 45,   0]])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 정밀도와 재현율"
      ],
      "metadata": {
        "id": "ZQpCZpOiifkD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score , recall_score\n",
        "\n",
        "print(\"정밀도:\", precision_score(y_test, fakepred))\n",
        "print(\"재현율:\", recall_score(y_test, fakepred))"
      ],
      "metadata": {
        "id": "hKb8moKC3NFi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "510bd187-1202-4154-83b9-515bc2f13423"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "정밀도: 0.0\n",
            "재현율: 0.0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score , recall_score , confusion_matrix\n",
        "\n",
        "def get_clf_eval(y_test , pred):\n",
        "    confusion = confusion_matrix( y_test, pred)\n",
        "    accuracy = accuracy_score(y_test , pred)\n",
        "    precision = precision_score(y_test , pred)\n",
        "    recall = recall_score(y_test , pred)\n",
        "    print('오차 행렬')\n",
        "    print(confusion)\n",
        "    print('정확도: {0:.4f}, 정밀도: {1:.4f}, 재현율: {2:.4f}'.format(accuracy , precision ,recall))"
      ],
      "metadata": {
        "id": "d7hAgo1yijuK"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "# 원본 데이터를 재로딩, 데이터 가공, 학습데이터/테스트 데이터 분할.\n",
        "titanic_df = pd.read_csv(r'/content/drive/MyDrive/CUAI/titanic.csv')\n",
        "y_titanic_df = titanic_df['Survived']\n",
        "X_titanic_df= titanic_df.drop('Survived', axis=1)\n",
        "X_titanic_df = transform_features(X_titanic_df)\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_titanic_df, y_titanic_df, \\\n",
        "                                                    test_size=0.20, random_state=11)\n",
        "\n",
        "lr_clf = LogisticRegression(solver='liblinear')\n",
        "\n",
        "lr_clf.fit(X_train , y_train)\n",
        "pred = lr_clf.predict(X_test)\n",
        "get_clf_eval(y_test , pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AHE_gLc-ioum",
        "outputId": "f00eb9a5-a8ce-45be-d0ec-81e0877e1189"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "오차 행렬\n",
            "[[108  10]\n",
            " [ 14  47]]\n",
            "정확도: 0.8659, 정밀도: 0.8246, 재현율: 0.7705\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pred_proba = lr_clf.predict_proba(X_test)\n",
        "pred  = lr_clf.predict(X_test)\n",
        "print('pred_proba()결과 Shape : {0}'.format(pred_proba.shape))\n",
        "print('pred_proba array에서 앞 3개만 샘플로 추출 \\n:', pred_proba[:3])\n",
        "\n",
        "# 예측 확률 array 와 예측 결과값 array 를 concatenate 하여 예측 확률과 결과값을 한눈에 확인\n",
        "pred_proba_result = np.concatenate([pred_proba , pred.reshape(-1,1)],axis=1)\n",
        "print('두개의 class 중에서 더 큰 확률을 클래스 값으로 예측 \\n',pred_proba_result[:3])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9UPneEwGiukE",
        "outputId": "7b3cd52a-e366-4ad1-a594-04643ebeb53b"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pred_proba()결과 Shape : (179, 2)\n",
            "pred_proba array에서 앞 3개만 샘플로 추출 \n",
            ": [[0.44935227 0.55064773]\n",
            " [0.86335512 0.13664488]\n",
            " [0.86429645 0.13570355]]\n",
            "두개의 class 중에서 더 큰 확률을 클래스 값으로 예측 \n",
            " [[0.44935227 0.55064773 1.        ]\n",
            " [0.86335512 0.13664488 0.        ]\n",
            " [0.86429645 0.13570355 0.        ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import Binarizer\n",
        "\n",
        "X = [[ 1, -1,  2],\n",
        "     [ 2,  0,  0],\n",
        "     [ 0,  1.1, 1.2]]\n",
        "\n",
        "# threshold 기준값보다 같거나 작으면 0을, 크면 1을 반환\n",
        "binarizer = Binarizer(threshold=1.1)\n",
        "print(binarizer.fit_transform(X))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "18tOqih5ixcj",
        "outputId": "10731664-1929-4689-c043-70ed8853220f"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 1.]\n",
            " [1. 0. 0.]\n",
            " [0. 0. 1.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import Binarizer\n",
        "\n",
        "#Binarizer의 threshold 설정값. 분류 결정 임곗값임.\n",
        "custom_threshold = 0.5\n",
        "\n",
        "# predict_proba( ) 반환값의 두번째 컬럼 , 즉 Positive 클래스 컬럼 하나만 추출하여 Binarizer를 적용\n",
        "pred_proba_1 = pred_proba[:,1].reshape(-1,1)\n",
        "\n",
        "binarizer = Binarizer(threshold=custom_threshold).fit(pred_proba_1)\n",
        "custom_predict = binarizer.transform(pred_proba_1)\n",
        "\n",
        "get_clf_eval(y_test, custom_predict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N-OvwyzgizUS",
        "outputId": "6254dfbc-472c-4f9e-bfa9-3beb11142537"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "오차 행렬\n",
            "[[108  10]\n",
            " [ 14  47]]\n",
            "정확도: 0.8659, 정밀도: 0.8246, 재현율: 0.7705\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Binarizer의 threshold 설정값을 0.4로 설정. 즉 분류 결정 임곗값을 0.5에서 0.4로 낮춤\n",
        "custom_threshold = 0.4\n",
        "pred_proba_1 = pred_proba[:,1].reshape(-1,1)\n",
        "binarizer = Binarizer(threshold=custom_threshold).fit(pred_proba_1)\n",
        "custom_predict = binarizer.transform(pred_proba_1)\n",
        "\n",
        "get_clf_eval(y_test , custom_predict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OD3zggq7i0_2",
        "outputId": "5a29d9ea-a4e1-4594-9a1a-2e3485bdfe05"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "오차 행렬\n",
            "[[97 21]\n",
            " [11 50]]\n",
            "정확도: 0.8212, 정밀도: 0.7042, 재현율: 0.8197\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 테스트를 수행할 모든 임곗값을 리스트 객체로 저장.\n",
        "thresholds = [0.4, 0.45, 0.50, 0.55, 0.60]\n",
        "\n",
        "def get_eval_by_threshold(y_test , pred_proba_c1, thresholds):\n",
        "    # thresholds list객체내의 값을 차례로 iteration하면서 Evaluation 수행.\n",
        "    for custom_threshold in thresholds:\n",
        "        binarizer = Binarizer(threshold=custom_threshold).fit(pred_proba_c1)\n",
        "        custom_predict = binarizer.transform(pred_proba_c1)\n",
        "        print('임곗값:',custom_threshold)\n",
        "        get_clf_eval(y_test , custom_predict)\n",
        "\n",
        "get_eval_by_threshold(y_test ,pred_proba[:,1].reshape(-1,1), thresholds )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ouiqu37ii264",
        "outputId": "6acc9f58-0682-4b61-e0e5-5f3fb3568f4b"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "임곗값: 0.4\n",
            "오차 행렬\n",
            "[[97 21]\n",
            " [11 50]]\n",
            "정확도: 0.8212, 정밀도: 0.7042, 재현율: 0.8197\n",
            "임곗값: 0.45\n",
            "오차 행렬\n",
            "[[105  13]\n",
            " [ 13  48]]\n",
            "정확도: 0.8547, 정밀도: 0.7869, 재현율: 0.7869\n",
            "임곗값: 0.5\n",
            "오차 행렬\n",
            "[[108  10]\n",
            " [ 14  47]]\n",
            "정확도: 0.8659, 정밀도: 0.8246, 재현율: 0.7705\n",
            "임곗값: 0.55\n",
            "오차 행렬\n",
            "[[111   7]\n",
            " [ 16  45]]\n",
            "정확도: 0.8715, 정밀도: 0.8654, 재현율: 0.7377\n",
            "임곗값: 0.6\n",
            "오차 행렬\n",
            "[[113   5]\n",
            " [ 17  44]]\n",
            "정확도: 0.8771, 정밀도: 0.8980, 재현율: 0.7213\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import precision_recall_curve\n",
        "\n",
        "# 레이블 값이 1일때의 예측 확률을 추출\n",
        "pred_proba_class1 = lr_clf.predict_proba(X_test)[:, 1]\n",
        "\n",
        "# 실제값 데이터 셋과 레이블 값이 1일 때의 예측 확률을 precision_recall_curve 인자로 입력\n",
        "precisions, recalls, thresholds = precision_recall_curve(y_test, pred_proba_class1 )\n",
        "print('반환된 분류 결정 임곗값 배열의 Shape:', thresholds.shape)\n",
        "print('반환된 precisions 배열의 Shape:', precisions.shape)\n",
        "print('반환된 recalls 배열의 Shape:', recalls.shape)\n",
        "\n",
        "print(\"thresholds 5 sample:\", thresholds[:5])\n",
        "print(\"precisions 5 sample:\", precisions[:5])\n",
        "print(\"recalls 5 sample:\", recalls[:5])\n",
        "\n",
        "#반환된 임계값 배열 로우가 147건이므로 샘플로 10건만 추출하되, 임곗값을 15 Step으로 추출.\n",
        "thr_index = np.arange(0, thresholds.shape[0], 15)\n",
        "print('샘플 추출을 위한 임계값 배열의 index 10개:', thr_index)\n",
        "print('샘플용 10개의 임곗값: ', np.round(thresholds[thr_index], 2))\n",
        "\n",
        "# 15 step 단위로 추출된 임계값에 따른 정밀도와 재현율 값\n",
        "print('샘플 임계값별 정밀도: ', np.round(precisions[thr_index], 3))\n",
        "print('샘플 임계값별 재현율: ', np.round(recalls[thr_index], 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "or8VNlVoi5hf",
        "outputId": "807747d4-6621-4fe2-8d96-15cad9b2368e"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "반환된 분류 결정 임곗값 배열의 Shape: (165,)\n",
            "반환된 precisions 배열의 Shape: (166,)\n",
            "반환된 recalls 배열의 Shape: (166,)\n",
            "thresholds 5 sample: [0.01974988 0.06956414 0.08402808 0.08474207 0.08920161]\n",
            "precisions 5 sample: [0.34078212 0.34269663 0.34463277 0.34659091 0.34857143]\n",
            "recalls 5 sample: [1. 1. 1. 1. 1.]\n",
            "샘플 추출을 위한 임계값 배열의 index 10개: [  0  15  30  45  60  75  90 105 120 135 150]\n",
            "샘플용 10개의 임곗값:  [0.02 0.11 0.13 0.14 0.16 0.24 0.32 0.45 0.62 0.73 0.87]\n",
            "샘플 임계값별 정밀도:  [0.341 0.372 0.401 0.44  0.505 0.598 0.688 0.774 0.915 0.968 0.938]\n",
            "샘플 임계값별 재현율:  [1.    1.    0.967 0.902 0.902 0.902 0.869 0.787 0.705 0.492 0.246]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.ticker as ticker\n",
        "%matplotlib inline\n",
        "\n",
        "def precision_recall_curve_plot(y_test , pred_proba_c1):\n",
        "    # threshold ndarray와 이 threshold에 따른 정밀도, 재현율 ndarray 추출.\n",
        "    precisions, recalls, thresholds = precision_recall_curve( y_test, pred_proba_c1)\n",
        "\n",
        "    # X축을 threshold값으로, Y축은 정밀도, 재현율 값으로 각각 Plot 수행. 정밀도는 점선으로 표시\n",
        "    plt.figure(figsize=(8,6))\n",
        "    threshold_boundary = thresholds.shape[0]\n",
        "    plt.plot(thresholds, precisions[0:threshold_boundary], linestyle='--', label='precision')\n",
        "    plt.plot(thresholds, recalls[0:threshold_boundary],label='recall')\n",
        "\n",
        "    # threshold 값 X 축의 Scale을 0.1 단위로 변경\n",
        "    start, end = plt.xlim()\n",
        "    plt.xticks(np.round(np.arange(start, end, 0.1),2))\n",
        "\n",
        "    # x축, y축 label과 legend, 그리고 grid 설정\n",
        "    plt.xlabel('Threshold value'); plt.ylabel('Precision and Recall value')\n",
        "    plt.legend(); plt.grid()\n",
        "    plt.show()\n",
        "\n",
        "precision_recall_curve_plot( y_test, lr_clf.predict_proba(X_test)[:, 1] )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "TWHDykB6i78O",
        "outputId": "2cee04a0-f15a-4348-d1f5-57c805981f80"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## F1 score"
      ],
      "metadata": {
        "id": "gsR_AwacjA_p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import f1_score\n",
        "f1 = f1_score(y_test , pred)\n",
        "print('F1 스코어: {0:.4f}'.format(f1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4R7ALReSi_NG",
        "outputId": "57965fd8-c409-4025-be13-eeb88a55890c"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1 스코어: 0.7966\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_clf_eval(y_test , pred):\n",
        "    confusion = confusion_matrix( y_test, pred)\n",
        "    accuracy = accuracy_score(y_test , pred)\n",
        "    precision = precision_score(y_test , pred)\n",
        "    recall = recall_score(y_test , pred)\n",
        "    # F1 스코어 추가\n",
        "    f1 = f1_score(y_test,pred)\n",
        "    print('오차 행렬')\n",
        "    print(confusion)\n",
        "    # f1 score print 추가\n",
        "    print('정확도: {0:.4f}, 정밀도: {1:.4f}, 재현율: {2:.4f}, F1:{3:.4f}'.format(accuracy, precision, recall, f1))\n",
        "\n",
        "thresholds = [0.4 , 0.45 , 0.50 , 0.55 , 0.60]\n",
        "pred_proba = lr_clf.predict_proba(X_test)\n",
        "get_eval_by_threshold(y_test, pred_proba[:,1].reshape(-1,1), thresholds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-0C33iXpjGty",
        "outputId": "8c5b1ef6-47c2-40be-9e5e-ea2642e57c53"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "임곗값: 0.4\n",
            "오차 행렬\n",
            "[[97 21]\n",
            " [11 50]]\n",
            "정확도: 0.8212, 정밀도: 0.7042, 재현율: 0.8197, F1:0.7576\n",
            "임곗값: 0.45\n",
            "오차 행렬\n",
            "[[105  13]\n",
            " [ 13  48]]\n",
            "정확도: 0.8547, 정밀도: 0.7869, 재현율: 0.7869, F1:0.7869\n",
            "임곗값: 0.5\n",
            "오차 행렬\n",
            "[[108  10]\n",
            " [ 14  47]]\n",
            "정확도: 0.8659, 정밀도: 0.8246, 재현율: 0.7705, F1:0.7966\n",
            "임곗값: 0.55\n",
            "오차 행렬\n",
            "[[111   7]\n",
            " [ 16  45]]\n",
            "정확도: 0.8715, 정밀도: 0.8654, 재현율: 0.7377, F1:0.7965\n",
            "임곗값: 0.6\n",
            "오차 행렬\n",
            "[[113   5]\n",
            " [ 17  44]]\n",
            "정확도: 0.8771, 정밀도: 0.8980, 재현율: 0.7213, F1:0.8000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ROC 곡선과 AUC"
      ],
      "metadata": {
        "id": "r4sKigQGjolG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import roc_curve\n",
        "\n",
        "# 레이블 값이 1일때의 예측 확률을 추출\n",
        "pred_proba_class1 = lr_clf.predict_proba(X_test)[:, 1]\n",
        "\n",
        "fprs , tprs , thresholds = roc_curve(y_test, pred_proba_class1)\n",
        "# 반환된 임곗값 배열에서 샘플로 데이터를 추출하되, 임곗값을 5 Step으로 추출.\n",
        "# thresholds[0]은 max(예측확률)+1로 임의 설정됨. 이를 제외하기 위해 np.arange는 1부터 시작\n",
        "thr_index = np.arange(1, thresholds.shape[0], 5)\n",
        "print('샘플 추출을 위한 임곗값 배열의 index:', thr_index)\n",
        "print('샘플 index로 추출한 임곗값: ', np.round(thresholds[thr_index], 2))\n",
        "\n",
        "# 5 step 단위로 추출된 임계값에 따른 FPR, TPR 값\n",
        "print('샘플 임곗값별 FPR: ', np.round(fprs[thr_index], 3))\n",
        "print('샘플 임곗값별 TPR: ', np.round(tprs[thr_index], 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3bXoWO-xjspx",
        "outputId": "dc4f689e-6b81-4d1b-ce18-57aaf79a14e3"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "샘플 추출을 위한 임곗값 배열의 index: [ 1  6 11 16 21 26 31 36 41 46]\n",
            "샘플 index로 추출한 임곗값:  [0.94 0.73 0.62 0.52 0.44 0.28 0.15 0.14 0.13 0.12]\n",
            "샘플 임곗값별 FPR:  [0.    0.008 0.025 0.076 0.127 0.254 0.576 0.61  0.746 0.847]\n",
            "샘플 임곗값별 TPR:  [0.016 0.492 0.705 0.738 0.803 0.885 0.902 0.951 0.967 1.   ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def roc_curve_plot(y_test , pred_proba_c1):\n",
        "    # 임곗값에 따른 FPR, TPR 값을 반환 받음.\n",
        "    fprs , tprs , thresholds = roc_curve(y_test ,pred_proba_c1)\n",
        "\n",
        "    # ROC Curve를 plot 곡선으로 그림.\n",
        "    plt.plot(fprs , tprs, label='ROC')\n",
        "    # 가운데 대각선 직선을 그림.\n",
        "    plt.plot([0, 1], [0, 1], 'k--', label='Random')\n",
        "\n",
        "    # FPR X 축의 Scale을 0.1 단위로 변경, X,Y 축명 설정등\n",
        "    start, end = plt.xlim()\n",
        "    plt.xticks(np.round(np.arange(start, end, 0.1),2))\n",
        "    plt.xlim(0,1); plt.ylim(0,1)\n",
        "    plt.xlabel('FPR( 1 - Specificity )'); plt.ylabel('TPR( Recall )')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "roc_curve_plot(y_test, lr_clf.predict_proba(X_test)[:, 1] )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 455
        },
        "id": "B9D006Mnk1y_",
        "outputId": "7a43bd82-f24c-4fc2-db79-1f2eed1e321f"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import roc_auc_score\n",
        "pred_proba = lr_clf.predict_proba(X_test)[:, 1]\n",
        "roc_score = roc_auc_score(y_test, pred_proba)\n",
        "print('ROC AUC 값: {0:.4f}'.format(roc_score))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uD9KR0Oel7KK",
        "outputId": "f17c2a96-7e59-4c89-90f8-0a028073085c"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ROC AUC 값: 0.8987\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_clf_eval(y_test, pred=None, pred_proba=None):\n",
        "    confusion = confusion_matrix( y_test, pred)\n",
        "    accuracy = accuracy_score(y_test , pred)\n",
        "    precision = precision_score(y_test , pred)\n",
        "    recall = recall_score(y_test , pred)\n",
        "    f1 = f1_score(y_test,pred)\n",
        "    # ROC-AUC 추가\n",
        "    roc_auc = roc_auc_score(y_test, pred_proba)\n",
        "    print('오차 행렬')\n",
        "    print(confusion)\n",
        "    # ROC-AUC print 추가\n",
        "    print('정확도: {0:.4f}, 정밀도: {1:.4f}, 재현율: {2:.4f},\\\n",
        "          F1: {3:.4f}, AUC:{4:.4f}'.format(accuracy, precision, recall, f1, roc_auc))"
      ],
      "metadata": {
        "id": "7dGRP7MUl-LZ"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 피마 인디언 당뇨병 예측"
      ],
      "metadata": {
        "id": "F5utxmWKl_3S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score\n",
        "from sklearn.metrics import f1_score, confusion_matrix, precision_recall_curve, roc_curve\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "diabetes_data = pd.read_csv(r'/content/drive/MyDrive/CUAI/diabetes.csv')\n",
        "print(diabetes_data['Outcome'].value_counts())\n",
        "diabetes_data.head(3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 196
        },
        "id": "TXkkcssfmDra",
        "outputId": "c01b3b4e-7f4d-4bd4-9cb3-47c2f558a4b8"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0    500\n",
            "1    268\n",
            "Name: Outcome, dtype: int64\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
              "0            6      148             72             35        0  33.6   \n",
              "1            1       85             66             29        0  26.6   \n",
              "2            8      183             64              0        0  23.3   \n",
              "\n",
              "   DiabetesPedigreeFunction  Age  Outcome  \n",
              "0                     0.627   50        1  \n",
              "1                     0.351   31        0  \n",
              "2                     0.672   32        1  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-4320c8a1-65a4-4d34-9d6d-d72768effe5f\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Pregnancies</th>\n",
              "      <th>Glucose</th>\n",
              "      <th>BloodPressure</th>\n",
              "      <th>SkinThickness</th>\n",
              "      <th>Insulin</th>\n",
              "      <th>BMI</th>\n",
              "      <th>DiabetesPedigreeFunction</th>\n",
              "      <th>Age</th>\n",
              "      <th>Outcome</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>6</td>\n",
              "      <td>148</td>\n",
              "      <td>72</td>\n",
              "      <td>35</td>\n",
              "      <td>0</td>\n",
              "      <td>33.6</td>\n",
              "      <td>0.627</td>\n",
              "      <td>50</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>85</td>\n",
              "      <td>66</td>\n",
              "      <td>29</td>\n",
              "      <td>0</td>\n",
              "      <td>26.6</td>\n",
              "      <td>0.351</td>\n",
              "      <td>31</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>8</td>\n",
              "      <td>183</td>\n",
              "      <td>64</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>23.3</td>\n",
              "      <td>0.672</td>\n",
              "      <td>32</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-4320c8a1-65a4-4d34-9d6d-d72768effe5f')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-4320c8a1-65a4-4d34-9d6d-d72768effe5f button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-4320c8a1-65a4-4d34-9d6d-d72768effe5f');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-e1eed056-592c-4bef-8504-50627c2601f9\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-e1eed056-592c-4bef-8504-50627c2601f9')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-e1eed056-592c-4bef-8504-50627c2601f9 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "diabetes_data",
              "summary": "{\n  \"name\": \"diabetes_data\",\n  \"rows\": 768,\n  \"fields\": [\n    {\n      \"column\": \"Pregnancies\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 3,\n        \"min\": 0,\n        \"max\": 17,\n        \"num_unique_values\": 17,\n        \"samples\": [\n          6,\n          1,\n          3\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Glucose\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 31,\n        \"min\": 0,\n        \"max\": 199,\n        \"num_unique_values\": 136,\n        \"samples\": [\n          151,\n          101,\n          112\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"BloodPressure\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 19,\n        \"min\": 0,\n        \"max\": 122,\n        \"num_unique_values\": 47,\n        \"samples\": [\n          86,\n          46,\n          85\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"SkinThickness\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 15,\n        \"min\": 0,\n        \"max\": 99,\n        \"num_unique_values\": 51,\n        \"samples\": [\n          7,\n          12,\n          48\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Insulin\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 115,\n        \"min\": 0,\n        \"max\": 846,\n        \"num_unique_values\": 186,\n        \"samples\": [\n          52,\n          41,\n          183\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"BMI\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 7.884160320375446,\n        \"min\": 0.0,\n        \"max\": 67.1,\n        \"num_unique_values\": 248,\n        \"samples\": [\n          19.9,\n          31.0,\n          38.1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"DiabetesPedigreeFunction\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.3313285950127749,\n        \"min\": 0.078,\n        \"max\": 2.42,\n        \"num_unique_values\": 517,\n        \"samples\": [\n          1.731,\n          0.426,\n          0.138\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Age\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 11,\n        \"min\": 21,\n        \"max\": 81,\n        \"num_unique_values\": 52,\n        \"samples\": [\n          60,\n          47,\n          72\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Outcome\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 1,\n        \"num_unique_values\": 2,\n        \"samples\": [\n          0,\n          1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "diabetes_data.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LV3GWiyurdhc",
        "outputId": "040fe7eb-275b-41c1-ef0b-fcd32df4c293"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 768 entries, 0 to 767\n",
            "Data columns (total 9 columns):\n",
            " #   Column                    Non-Null Count  Dtype  \n",
            "---  ------                    --------------  -----  \n",
            " 0   Pregnancies               768 non-null    int64  \n",
            " 1   Glucose                   768 non-null    int64  \n",
            " 2   BloodPressure             768 non-null    int64  \n",
            " 3   SkinThickness             768 non-null    int64  \n",
            " 4   Insulin                   768 non-null    int64  \n",
            " 5   BMI                       768 non-null    float64\n",
            " 6   DiabetesPedigreeFunction  768 non-null    float64\n",
            " 7   Age                       768 non-null    int64  \n",
            " 8   Outcome                   768 non-null    int64  \n",
            "dtypes: float64(2), int64(7)\n",
            "memory usage: 54.1 KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 피처 데이터 세트 X, 레이블 데이터 세트 y를 추출.\n",
        "# 맨 끝이 Outcome 컬럼으로 레이블 값임. 컬럼 위치 -1을 이용해 추출\n",
        "X = diabetes_data.iloc[:, :-1]\n",
        "y = diabetes_data.iloc[:, -1]\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 156, stratify=y)\n",
        "\n",
        "# 로지스틱 회귀로 학습,예측 및 평가 수행.\n",
        "lr_clf = LogisticRegression(solver='liblinear')\n",
        "lr_clf.fit(X_train , y_train)\n",
        "pred = lr_clf.predict(X_test)\n",
        "pred_proba = lr_clf.predict_proba(X_test)[:, 1]\n",
        "\n",
        "get_clf_eval(y_test , pred, pred_proba)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UnHBwqnKrgxY",
        "outputId": "8c077049-0ad2-46f4-fc51-4bba929b7880"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "오차 행렬\n",
            "[[87 13]\n",
            " [22 32]]\n",
            "정확도: 0.7727, 정밀도: 0.7111, 재현율: 0.5926,          F1: 0.6465, AUC:0.8083\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pred_proba_c1 = lr_clf.predict_proba(X_test)[:, 1]\n",
        "precision_recall_curve_plot(y_test, pred_proba_c1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "mjwWNq-qrw59",
        "outputId": "1c63a537-aa7b-4693-ad84-6b61998dbf10"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "diabetes_data.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "Rc16yyBOsXJs",
        "outputId": "7c18810a-fc84-48dc-9747-5cbef76a5f9c"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "       Pregnancies     Glucose  BloodPressure  SkinThickness     Insulin  \\\n",
              "count   768.000000  768.000000     768.000000     768.000000  768.000000   \n",
              "mean      3.845052  120.894531      69.105469      20.536458   79.799479   \n",
              "std       3.369578   31.972618      19.355807      15.952218  115.244002   \n",
              "min       0.000000    0.000000       0.000000       0.000000    0.000000   \n",
              "25%       1.000000   99.000000      62.000000       0.000000    0.000000   \n",
              "50%       3.000000  117.000000      72.000000      23.000000   30.500000   \n",
              "75%       6.000000  140.250000      80.000000      32.000000  127.250000   \n",
              "max      17.000000  199.000000     122.000000      99.000000  846.000000   \n",
              "\n",
              "              BMI  DiabetesPedigreeFunction         Age     Outcome  \n",
              "count  768.000000                768.000000  768.000000  768.000000  \n",
              "mean    31.992578                  0.471876   33.240885    0.348958  \n",
              "std      7.884160                  0.331329   11.760232    0.476951  \n",
              "min      0.000000                  0.078000   21.000000    0.000000  \n",
              "25%     27.300000                  0.243750   24.000000    0.000000  \n",
              "50%     32.000000                  0.372500   29.000000    0.000000  \n",
              "75%     36.600000                  0.626250   41.000000    1.000000  \n",
              "max     67.100000                  2.420000   81.000000    1.000000  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-ca611340-be02-4bd0-b57c-cef43627125e\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Pregnancies</th>\n",
              "      <th>Glucose</th>\n",
              "      <th>BloodPressure</th>\n",
              "      <th>SkinThickness</th>\n",
              "      <th>Insulin</th>\n",
              "      <th>BMI</th>\n",
              "      <th>DiabetesPedigreeFunction</th>\n",
              "      <th>Age</th>\n",
              "      <th>Outcome</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "      <td>768.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>3.845052</td>\n",
              "      <td>120.894531</td>\n",
              "      <td>69.105469</td>\n",
              "      <td>20.536458</td>\n",
              "      <td>79.799479</td>\n",
              "      <td>31.992578</td>\n",
              "      <td>0.471876</td>\n",
              "      <td>33.240885</td>\n",
              "      <td>0.348958</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>3.369578</td>\n",
              "      <td>31.972618</td>\n",
              "      <td>19.355807</td>\n",
              "      <td>15.952218</td>\n",
              "      <td>115.244002</td>\n",
              "      <td>7.884160</td>\n",
              "      <td>0.331329</td>\n",
              "      <td>11.760232</td>\n",
              "      <td>0.476951</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.078000</td>\n",
              "      <td>21.000000</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>1.000000</td>\n",
              "      <td>99.000000</td>\n",
              "      <td>62.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>27.300000</td>\n",
              "      <td>0.243750</td>\n",
              "      <td>24.000000</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>3.000000</td>\n",
              "      <td>117.000000</td>\n",
              "      <td>72.000000</td>\n",
              "      <td>23.000000</td>\n",
              "      <td>30.500000</td>\n",
              "      <td>32.000000</td>\n",
              "      <td>0.372500</td>\n",
              "      <td>29.000000</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>6.000000</td>\n",
              "      <td>140.250000</td>\n",
              "      <td>80.000000</td>\n",
              "      <td>32.000000</td>\n",
              "      <td>127.250000</td>\n",
              "      <td>36.600000</td>\n",
              "      <td>0.626250</td>\n",
              "      <td>41.000000</td>\n",
              "      <td>1.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>17.000000</td>\n",
              "      <td>199.000000</td>\n",
              "      <td>122.000000</td>\n",
              "      <td>99.000000</td>\n",
              "      <td>846.000000</td>\n",
              "      <td>67.100000</td>\n",
              "      <td>2.420000</td>\n",
              "      <td>81.000000</td>\n",
              "      <td>1.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ca611340-be02-4bd0-b57c-cef43627125e')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-ca611340-be02-4bd0-b57c-cef43627125e button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-ca611340-be02-4bd0-b57c-cef43627125e');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-9bb2ddbb-9efd-4ce0-b5c5-b8b32a68ab67\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-9bb2ddbb-9efd-4ce0-b5c5-b8b32a68ab67')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-9bb2ddbb-9efd-4ce0-b5c5-b8b32a68ab67 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "summary": "{\n  \"name\": \"diabetes_data\",\n  \"rows\": 8,\n  \"fields\": [\n    {\n      \"column\": \"Pregnancies\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 269.85223453356366,\n        \"min\": 0.0,\n        \"max\": 768.0,\n        \"num_unique_values\": 8,\n        \"samples\": [\n          3.8450520833333335,\n          3.0,\n          768.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Glucose\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 243.73802348295857,\n        \"min\": 0.0,\n        \"max\": 768.0,\n        \"num_unique_values\": 8,\n        \"samples\": [\n          120.89453125,\n          117.0,\n          768.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"BloodPressure\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 252.8525053581062,\n        \"min\": 0.0,\n        \"max\": 768.0,\n        \"num_unique_values\": 8,\n        \"samples\": [\n          69.10546875,\n          72.0,\n          768.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"SkinThickness\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 263.7684730531098,\n        \"min\": 0.0,\n        \"max\": 768.0,\n        \"num_unique_values\": 7,\n        \"samples\": [\n          768.0,\n          20.536458333333332,\n          32.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Insulin\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 350.26059167945886,\n        \"min\": 0.0,\n        \"max\": 846.0,\n        \"num_unique_values\": 7,\n        \"samples\": [\n          768.0,\n          79.79947916666667,\n          127.25\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"BMI\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 262.05117817552093,\n        \"min\": 0.0,\n        \"max\": 768.0,\n        \"num_unique_values\": 8,\n        \"samples\": [\n          31.992578124999998,\n          32.0,\n          768.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"DiabetesPedigreeFunction\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 271.3005221658502,\n        \"min\": 0.078,\n        \"max\": 768.0,\n        \"num_unique_values\": 8,\n        \"samples\": [\n          0.47187630208333325,\n          0.3725,\n          768.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Age\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 260.1941178528413,\n        \"min\": 11.760231540678685,\n        \"max\": 768.0,\n        \"num_unique_values\": 8,\n        \"samples\": [\n          33.240885416666664,\n          29.0,\n          768.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Outcome\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 271.3865920388932,\n        \"min\": 0.0,\n        \"max\": 768.0,\n        \"num_unique_values\": 5,\n        \"samples\": [\n          0.3489583333333333,\n          1.0,\n          0.47695137724279896\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.hist(diabetes_data['Glucose'], bins=100)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "Ml2azz2isjYg",
        "outputId": "0c3df64c-ac54-4526-de34-e6ce152c2d03"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 0값을 검사할 피처명 리스트 객체 설정\n",
        "zero_features = ['Glucose', 'BloodPressure','SkinThickness','Insulin','BMI']\n",
        "\n",
        "# 전체 데이터 건수\n",
        "total_count = diabetes_data['Glucose'].count()\n",
        "\n",
        "# 피처별로 반복 하면서 데이터 값이 0 인 데이터 건수 추출하고, 퍼센트 계산\n",
        "for feature in zero_features:\n",
        "    zero_count = diabetes_data[diabetes_data[feature] == 0][feature].count()\n",
        "    print('{0} 0 건수는 {1}, 퍼센트는 {2:.2f} %'.format(feature, zero_count, 100*zero_count/total_count))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QFdXhT7GsjvF",
        "outputId": "b6eac363-67b0-40e9-8c6d-efcc09601936"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Glucose 0 건수는 5, 퍼센트는 0.65 %\n",
            "BloodPressure 0 건수는 35, 퍼센트는 4.56 %\n",
            "SkinThickness 0 건수는 227, 퍼센트는 29.56 %\n",
            "Insulin 0 건수는 374, 퍼센트는 48.70 %\n",
            "BMI 0 건수는 11, 퍼센트는 1.43 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# zero_features 리스트 내부에 저장된 개별 피처들에 대해서 0값을 평균 값으로 대체\n",
        "mean_zero_features = diabetes_data[zero_features].mean()\n",
        "diabetes_data[zero_features]=diabetes_data[zero_features].replace(0, mean_zero_features)"
      ],
      "metadata": {
        "id": "Mv49Z0PYsoyr"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X = diabetes_data.iloc[:, :-1]\n",
        "y = diabetes_data.iloc[:, -1]\n",
        "\n",
        "# StandardScaler 클래스를 이용해 피처 데이터 세트에 일괄적으로 스케일링 적용\n",
        "scaler = StandardScaler( )\n",
        "X_scaled = scaler.fit_transform(X)\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size = 0.2, random_state = 156, stratify=y)\n",
        "\n",
        "# 로지스틱 회귀로 학습, 예측 및 평가 수행.\n",
        "lr_clf = LogisticRegression()\n",
        "lr_clf.fit(X_train , y_train)\n",
        "pred = lr_clf.predict(X_test)\n",
        "pred_proba = lr_clf.predict_proba(X_test)[:, 1]\n",
        "\n",
        "get_clf_eval(y_test , pred, pred_proba)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "msSbOsNEs336",
        "outputId": "d0f5fc4e-3149-4d83-810c-9c46c7b40e30"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "오차 행렬\n",
            "[[90 10]\n",
            " [21 33]]\n",
            "정확도: 0.7987, 정밀도: 0.7674, 재현율: 0.6111,          F1: 0.6804, AUC:0.8433\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import Binarizer\n",
        "\n",
        "def get_eval_by_threshold(y_test , pred_proba_c1, thresholds):\n",
        "    # thresholds 리스트 객체내의 값을 차례로 iteration하면서 Evaluation 수행.\n",
        "    for custom_threshold in thresholds:\n",
        "        binarizer = Binarizer(threshold=custom_threshold).fit(pred_proba_c1)\n",
        "        custom_predict = binarizer.transform(pred_proba_c1)\n",
        "        print('임곗값:',custom_threshold)\n",
        "        get_clf_eval(y_test , custom_predict, pred_proba_c1)"
      ],
      "metadata": {
        "id": "CoNN625Ytt1g"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "thresholds = [0.3 , 0.33 ,0.36,0.39, 0.42 , 0.45 ,0.48, 0.50]\n",
        "pred_proba = lr_clf.predict_proba(X_test)\n",
        "get_eval_by_threshold(y_test, pred_proba[:,1].reshape(-1,1), thresholds )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "71JntPQps64T",
        "outputId": "8fb44475-1a0c-4314-ddbe-b743d57b1fe4"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "임곗값: 0.3\n",
            "오차 행렬\n",
            "[[67 33]\n",
            " [11 43]]\n",
            "정확도: 0.7143, 정밀도: 0.5658, 재현율: 0.7963,          F1: 0.6615, AUC:0.8433\n",
            "임곗값: 0.33\n",
            "오차 행렬\n",
            "[[72 28]\n",
            " [12 42]]\n",
            "정확도: 0.7403, 정밀도: 0.6000, 재현율: 0.7778,          F1: 0.6774, AUC:0.8433\n",
            "임곗값: 0.36\n",
            "오차 행렬\n",
            "[[76 24]\n",
            " [15 39]]\n",
            "정확도: 0.7468, 정밀도: 0.6190, 재현율: 0.7222,          F1: 0.6667, AUC:0.8433\n",
            "임곗값: 0.39\n",
            "오차 행렬\n",
            "[[78 22]\n",
            " [16 38]]\n",
            "정확도: 0.7532, 정밀도: 0.6333, 재현율: 0.7037,          F1: 0.6667, AUC:0.8433\n",
            "임곗값: 0.42\n",
            "오차 행렬\n",
            "[[84 16]\n",
            " [18 36]]\n",
            "정확도: 0.7792, 정밀도: 0.6923, 재현율: 0.6667,          F1: 0.6792, AUC:0.8433\n",
            "임곗값: 0.45\n",
            "오차 행렬\n",
            "[[85 15]\n",
            " [18 36]]\n",
            "정확도: 0.7857, 정밀도: 0.7059, 재현율: 0.6667,          F1: 0.6857, AUC:0.8433\n",
            "임곗값: 0.48\n",
            "오차 행렬\n",
            "[[88 12]\n",
            " [19 35]]\n",
            "정확도: 0.7987, 정밀도: 0.7447, 재현율: 0.6481,          F1: 0.6931, AUC:0.8433\n",
            "임곗값: 0.5\n",
            "오차 행렬\n",
            "[[90 10]\n",
            " [21 33]]\n",
            "정확도: 0.7987, 정밀도: 0.7674, 재현율: 0.6111,          F1: 0.6804, AUC:0.8433\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 임곗값를 0.48로 설정한 Binarizer 생성\n",
        "binarizer = Binarizer(threshold=0.48)\n",
        "\n",
        "# 위에서 구한 lr_clf의 predict_proba() 예측 확률 array에서 1에 해당하는 컬럼값을 Binarizer변환.\n",
        "pred_th_048 = binarizer.fit_transform(pred_proba[:, 1].reshape(-1,1))\n",
        "\n",
        "get_clf_eval(y_test , pred_th_048, pred_proba[:, 1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "77Bv1o-vt33t",
        "outputId": "93c94941-7185-41aa-9853-687451374d81"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "오차 행렬\n",
            "[[88 12]\n",
            " [19 35]]\n",
            "정확도: 0.7987, 정밀도: 0.7447, 재현율: 0.6481,          F1: 0.6931, AUC:0.8433\n"
          ]
        }
      ]
    }
  ]
}