_4_문서_분류(Document_Classification).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yoonjong8739/NLP_study/blob/master/_4_%EB%AC%B8%EC%84%9C_%EB%B6%84%EB%A5%98(Document_Classification).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "meRAQbe3ArB7"
      },
      "source": [
        "# 문서 분류(Document Classification)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "myxaNrtIl7Z0"
      },
      "source": [
        "## 데이터 준비"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e85EZuHb-Z9f"
      },
      "source": [
        "* 문서 분류에 필요한 데이터는 `scikit-learn`이 제공하는 20개의 주제를 가지는 뉴스그룹 데이터를 사용\n",
        "* 텍스트는 `CounterVectorizer`를 거쳐 DTM으로 변환\n",
        "* DTM 행렬은 문서에 등장하는 단어들을 빈도 수 별로 표현한 행렬\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AYsGQgxCl-kQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20080eba-b559-42d4-c6df-6eeb62072f66"
      },
      "source": [
        "from sklearn.datasets import fetch_20newsgroups\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "news = fetch_20newsgroups()\n",
        "\n",
        "x = news.data\n",
        "y = news.target\n",
        "\n",
        "cv = CountVectorizer()\n",
        "x = cv.fit_transform(x)\n",
        "\n",
        "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3)\n",
        "print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(7919, 130107) (7919,) (3395, 130107) (3395,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4iRARmcl_EmI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "72ae02ff-d0be-4b56-d4d8-37ee770e8bc5"
      },
      "source": [
        "print(x_train[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  (0, 56979)\t9\n",
            "  (0, 50527)\t1\n",
            "  (0, 124031)\t1\n",
            "  (0, 85354)\t1\n",
            "  (0, 111322)\t1\n",
            "  (0, 68532)\t3\n",
            "  (0, 114731)\t5\n",
            "  (0, 90379)\t1\n",
            "  (0, 89362)\t36\n",
            "  (0, 76032)\t1\n",
            "  (0, 90774)\t1\n",
            "  (0, 42876)\t2\n",
            "  (0, 89860)\t2\n",
            "  (0, 104813)\t3\n",
            "  (0, 114455)\t53\n",
            "  (0, 68766)\t1\n",
            "  (0, 115475)\t12\n",
            "  (0, 32311)\t2\n",
            "  (0, 37433)\t1\n",
            "  (0, 123796)\t1\n",
            "  (0, 66608)\t7\n",
            "  (0, 27436)\t3\n",
            "  (0, 90252)\t2\n",
            "  (0, 62221)\t1\n",
            "  (0, 35187)\t1\n",
            "  :\t:\n",
            "  (0, 52003)\t1\n",
            "  (0, 104741)\t1\n",
            "  (0, 45272)\t1\n",
            "  (0, 49087)\t2\n",
            "  (0, 32454)\t1\n",
            "  (0, 88418)\t1\n",
            "  (0, 102109)\t1\n",
            "  (0, 87835)\t1\n",
            "  (0, 70161)\t1\n",
            "  (0, 26855)\t1\n",
            "  (0, 102110)\t1\n",
            "  (0, 96392)\t8\n",
            "  (0, 81270)\t1\n",
            "  (0, 100917)\t1\n",
            "  (0, 111166)\t1\n",
            "  (0, 25627)\t1\n",
            "  (0, 53726)\t1\n",
            "  (0, 50215)\t1\n",
            "  (0, 111666)\t1\n",
            "  (0, 25626)\t1\n",
            "  (0, 96976)\t1\n",
            "  (0, 55137)\t1\n",
            "  (0, 68419)\t1\n",
            "  (0, 32668)\t1\n",
            "  (0, 118784)\t1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JGM2WbEdAsGL"
      },
      "source": [
        "## scikit-learn을 이용한 문서 분류"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M7g4PrqerCkj"
      },
      "source": [
        "from sklearn.metrics import accuracy_score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jnww8xssA-FL"
      },
      "source": [
        "### Logistic Regression"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mgUTDK7o9wC6"
      },
      "source": [
        "* Logistic Regression은 특성상 다중 분류에는 적합하지 않음"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rk3jq9p9DCcv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "533b4101-7901-4dfa-efb0-b04d03676ed5"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "LR = LogisticRegression()\n",
        "LR.fit(x_train, y_train)\n",
        "\n",
        "pred = LR.predict(x_test)\n",
        "acc = accuracy_score(y_test, pred)\n",
        "print(acc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8642120765832106\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/linear_model/_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
            "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
            "\n",
            "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
            "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
            "Please also refer to the documentation for alternative solver options:\n",
            "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
            "  n_iter_i = _check_optimize_result(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 서포트 벡터 머신(Support Vector Machines)\n",
        "- 회귀, 분류, 이상치 탐지 등에 사용되는 지도학습 방법\n",
        "- 클래스 사이의 경계에 위치한 데이터 포인트를 서포트 벡터라고 함\n",
        "- 각 서포트 벡터가 클래스 사이의 결정 경계를 구분하는데 얼마나 중요한지를 학습\n",
        "- 각 서포트 벡터 사이의 마진이 가장 큰 방향으로 학습\n",
        "- 서포트 벡터 까지의 거리와 서포트 벡터의 중요도를 기반으로 예측을 수행"
      ],
      "metadata": {
        "id": "cgq8DhyczFJl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn import svm\n",
        "\n",
        "SVM = svm.SVC(kernel='linear')\n",
        "SVM.fit(x_train, y_train)\n",
        "\n",
        "pred = SVM.predict(x_test)\n",
        "acc = accuracy_score(y_test, pred)\n",
        "print(acc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OiKXkcfezgtl",
        "outputId": "38264edb-a247-403e-813a-1dae6474c10e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8167893961708395\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M4g1mEefA-SU"
      },
      "source": [
        "### Naive Bayes\n",
        "- 베이즈 정리를 적용한 확률적 분류 알고리즘\n",
        "- 모든 특성들이 독립임을 가정(naive 가정)\n",
        "- 입력 특성에 따라 3개의 분류기 존재\n",
        "    - 가우시안 나이브 베이즈 분류기\n",
        "    - 베르누이 나이브 베이즈 분류기\n",
        "    - 다항 나이브 베이즈 분류기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qcIkL0Bx-AIG"
      },
      "source": [
        "#### DTM을 이용한 Naive Bayes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ogbxoPS0DMTd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "609cc17d-37f0-4e98-84e6-6092350cdc1b"
      },
      "source": [
        "from sklearn.naive_bayes import MultinomialNB\n",
        "\n",
        "NB = MultinomialNB()\n",
        "NB.fit(x_train, y_train)\n",
        "pred = NB.predict(x_test)\n",
        "acc = accuracy_score(y_test, pred)\n",
        "print(acc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8256259204712812\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xZC7kjWt961H"
      },
      "source": [
        "#### tf-idf를 이용한 정확도 향상"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c2j7cZc71yiJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f405666e-982d-469a-c4db-bdd847796836"
      },
      "source": [
        "from sklearn.feature_extraction.text import TfidfTransformer\n",
        "\n",
        "tfidf = TfidfTransformer()\n",
        "x_train_tf = tfidf.fit_transform(x_train)\n",
        "x_test_tf = tfidf.transform(x_test)\n",
        "\n",
        "NB.fit(x_train_tf, y_train)\n",
        "pred = NB.predict(x_test_tf)\n",
        "acc = accuracy_score(y_test, pred)\n",
        "print(acc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8406480117820324\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YPeounJWA-e6"
      },
      "source": [
        "### Decision Tree\n",
        "- 분류와 회귀에 사용되는 지도 학습 방법\n",
        "- 데이터 특성으로 부터 추론된 결정 규칙을 통해 값을 예측\n",
        "- **if-then-else** 결정 규칙을 통해 데이터 학습\n",
        "- 트리의 깊이가 깊을수록 복잡한 모델"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "62wyoby4EEDb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "060eb4be-1659-4f3b-e1c0-2c1dcad7a374"
      },
      "source": [
        "from sklearn.tree import DecisionTreeClassifier\n",
        "\n",
        "DT = DecisionTreeClassifier()\n",
        "DT.fit(x_train, y_train)\n",
        "pred = DT.predict(x_test)\n",
        "acc = accuracy_score(y_test, pred)\n",
        "print(acc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.6279823269513991\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UeEPOjxxA-my"
      },
      "source": [
        "### XGBoost\n",
        "- 트리 기반의 앙상블 기법\n",
        "- 분류에 있어서 다른 알고리즘보다 좋은 예측 성능을 보여줌\n",
        "- XGBoost는 GBM 기반이지만, GBM의 단점인 느린 수행 시간과 과적합 규제 부재 등의 문제를 해결\n",
        "- 병렬 CPU 환경에서 빠르게 학습 가능"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4TAgLK5ECCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "385e68ae-9d91-40c8-9e4c-6f08831bcd06"
      },
      "source": [
        "from xgboost import XGBClassifier\n",
        "\n",
        "xgb = XGBClassifier(n_estimators=30, learning_rate=0.05, max_depth=3)\n",
        "xgb.fit(x_train, y_train)\n",
        "pred = xgb.predict(x_test)\n",
        "acc = accuracy_score(y_test, pred)\n",
        "print(acc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.7063328424153167\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1b4PWPBAWwn"
      },
      "source": [
        "##교차 검증"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bd7AexinGlYP"
      },
      "source": [
        "* 일반 검증은 학습 데이터가 테스트 데이터로 사용되지 않음\n",
        "* 교차 검증은 데이터를 n개의 집합으로 나누어 정확도를 계산해 학습 데이터로 사용된 데이터도 테스트 데이터로 사용\n",
        "* 교차 검증을 사용하면 일반 검증보다 모델의 일반화가 잘 되어 있는지 평가 가능\n",
        "* 앞서 구성한 나이브 베이즈 모델을 교차 검증"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZzaiICzaHrI7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "095ddbfa-ffa1-4ad5-af0f-66c8519675d3"
      },
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "\n",
        "scores = cross_val_score(estimator=NB, X=x, y=y, cv=5)\n",
        "print(scores, scores.mean())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.83870968 0.83826779 0.82368537 0.83031374 0.83642794] 0.833480903927519\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVQBNi5lIn3X"
      },
      "source": [
        "* 교차 검증을 통해 일반 검증보다 좀 더 일반화된 모델 생성 가능\n",
        "* 교차 검증은 일반 검증에 비해 n번 검증을 해 비용이 더 많이 소요"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uqIU3r_9AZQm"
      },
      "source": [
        "## 정밀도와 재현률"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5C0ZPgKLJSvt"
      },
      "source": [
        "* 정밀도(precision)는 양성 클래스(정답)으로 예측한 샘플이 양성 클래스일 확률을 의미\n",
        "* 모델이 얼마나 양성 클래스를 잘 예측하는지를 나타냄\n",
        "* 재현률(recall)은 양성 클래스인 샘플에서 모델이 양성 클래스로 예측한 샘플 비율을 의미하며, 모델이 얼마나 실제 상황을 재현하는지를 나타냄\n",
        "* 정밀도와 재현율의 가중조화평균인 F1-score라는 지표는 정확도에 비해 더 효과적인 모델 분석 지표로 알려져 있음\n",
        "* 직접 계산할 수도 있으나, scikit-learn은 이를 편리하게 계산해주는 함수를 제공"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y3hObzsrNuzF"
      },
      "source": [
        "* 다중 클래스 분류 문제에서 정밀도와 재현률을 계산할 때는 클래스간의 지표를 어떻게 합칠지 지정 필요\n",
        "\n",
        "  * None - 클래스간 지표를 합치지 말고 그대로 출력\n",
        "  * micro - 정밀도와 재현률이 같음, 이로 인해 f1-score도 정밀도, 재현률과 동일\n",
        "  * macro - 클래스간 지표를 단순 평균한 값\n",
        "  * weighted - 클래스간 지표를 가중 평균한 값"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "98npJWW8J9Px",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e586521-21b1-42bb-9efe-90e428139dc7"
      },
      "source": [
        "from sklearn.metrics import precision_score, recall_score, f1_score\n",
        "\n",
        "precision = precision_score(y_test, pred, average='micro')\n",
        "recall = recall_score(y_test, pred, average='micro')\n",
        "f1 = f1_score(y_test, pred, average='micro')\n",
        "\n",
        "print(precision, recall, f1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.7063328424153167 0.7063328424153167 0.7063328424153167\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3JPcMoD0NQi6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ce897de-4ce7-4f58-c8b3-0e51b350cd9e"
      },
      "source": [
        "precision = precision_score(y_test, pred, average='macro')\n",
        "recall = recall_score(y_test, pred, average='macro')\n",
        "f1 = f1_score(y_test, pred, average='macro')\n",
        "\n",
        "print(precision, recall, f1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.7479917086464207 0.6994455681697204 0.7130822104645628\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QY3s-EXdArpC"
      },
      "source": [
        "## 그리드 검색을 이용한 파라미터 최적화"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z0rY-TxKCsOi"
      },
      "source": [
        "* 그리드 검색을 사용하면 분류기에 사용하는 파라미터 최적화 가능\n",
        "* 그리드 검색을 통해 앞서 구성한 나이브 베이즈 모델의 'alpha' 파라미터를 최적화시키는 예제"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jOkeA7siDdvF"
      },
      "source": [
        "* `estimator`: 사용 모델 객체     \n",
        "* `param_grid`: 사용 객체:지정 파라미터 리스트로 구성된 딕셔너리    \n",
        "* `scoring`: 최적화하고자 하는 성능 지표   \n",
        "* `cv`: 교차 검증 분할 개수      "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCheUO9YBgRi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9264ec8-dcf4-41d9-e110-c42b614176f6"
      },
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "\n",
        "GS = GridSearchCV(estimator=NB,\n",
        "                  param_grid={'alpha':[0.0006, 0.0008, 0.001]},\n",
        "                  scoring=\"accuracy\",\n",
        "                  cv=10)\n",
        "\n",
        "GS.fit(x, y)\n",
        "\n",
        "print(GS.best_score_)\n",
        "print(GS.best_params_)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8897820965842167\n",
            "{'alpha': 0.001}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JM5vwqUZBq-j"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}