4_Document_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "4_Document_Classification.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "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 : Document Term Matrix\n",
        "* DTM 행렬은 문서에 등장하는 단어들을 빈도 수 별로 표현한 행렬\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AYsGQgxCl-kQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afdceaee-9561-4f60-c37d-796ec99e12cc"
      },
      "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": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading 20news dataset. This may take a few minutes.\n",
            "Downloading dataset from https://ndownloader.figshare.com/files/5975967 (14 MB)\n"
          ]
        },
        {
          "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": "d3b8733c-865a-4572-a153-a274e771afe0"
      },
      "source": [
        "print(x_train[0])"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  (0, 56979)\t1\n",
            "  (0, 50527)\t2\n",
            "  (0, 114688)\t1\n",
            "  (0, 111322)\t1\n",
            "  (0, 114731)\t2\n",
            "  (0, 87620)\t1\n",
            "  (0, 95162)\t1\n",
            "  (0, 64095)\t1\n",
            "  (0, 90379)\t1\n",
            "  (0, 89362)\t2\n",
            "  (0, 76032)\t1\n",
            "  (0, 123292)\t3\n",
            "  (0, 89860)\t1\n",
            "  (0, 114455)\t7\n",
            "  (0, 68766)\t2\n",
            "  (0, 115475)\t6\n",
            "  (0, 32311)\t2\n",
            "  (0, 66608)\t3\n",
            "  (0, 27436)\t1\n",
            "  (0, 37565)\t1\n",
            "  (0, 128402)\t2\n",
            "  (0, 35983)\t1\n",
            "  (0, 111695)\t1\n",
            "  (0, 56283)\t1\n",
            "  (0, 29573)\t2\n",
            "  :\t:\n",
            "  (0, 48981)\t1\n",
            "  (0, 6514)\t1\n",
            "  (0, 75717)\t2\n",
            "  (0, 65678)\t2\n",
            "  (0, 113370)\t2\n",
            "  (0, 90128)\t1\n",
            "  (0, 75955)\t1\n",
            "  (0, 110634)\t4\n",
            "  (0, 62762)\t3\n",
            "  (0, 59922)\t1\n",
            "  (0, 59542)\t1\n",
            "  (0, 60410)\t2\n",
            "  (0, 63674)\t1\n",
            "  (0, 14969)\t1\n",
            "  (0, 20339)\t1\n",
            "  (0, 20674)\t1\n",
            "  (0, 6107)\t1\n",
            "  (0, 5562)\t1\n",
            "  (0, 2850)\t1\n",
            "  (0, 41796)\t1\n",
            "  (0, 114561)\t1\n",
            "  (0, 41322)\t1\n",
            "  (0, 37729)\t1\n",
            "  (0, 119928)\t1\n",
            "  (0, 41905)\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": 3,
      "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": "6b963f9f-dc17-42c0-8189-2bcc5b1331e0"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "LR = LogisticRegression()\n",
        "LR.fit(x_train, y_train)\n",
        "pred = LR.predict(x_test)\n",
        "acc = accuracy_score(pred, y_test)\n",
        "print(acc)\n",
        "\n",
        "# 성능이 나쁘지 않더라도 20개에 대한 분류를 로지스틱 회귀를 활용했기 때문에 사용하기 좋은 모델은 아니다."
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8739322533136966\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: 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",
            "  extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M4g1mEefA-SU"
      },
      "source": [
        "### Naive Bayes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X7onVFOIFv09"
      },
      "source": [
        "## 나이브 베이스 분류기 ( Naive Bayes Classification )\n",
        "\n",
        "* 베이즈 정리를 적용한 확률적 분류 알고리즘\n",
        "* 모든 특성들이 독립임을 가정 ( naive 가정 )\n",
        "* 입력 특성에 따라 3개의 분류기 존재\n",
        "-- 가우시간 나이브 베이즈 분류기\n",
        "-- 베르누이 나이브 베이즈 분류기\n",
        "-- 다항 나이브 베이즈 분류기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qcIkL0Bx-AIG"
      },
      "source": [
        "#### DTM을 이용한 Naive Bayes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T8fYOSbFFsyk",
        "outputId": "198684d3-70bd-4e65-d4f0-d4f841b9e9b2"
      },
      "source": [
        "# 다항 나이브 베이즈 분류기 사용\n",
        "\n",
        "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(pred, y_test)\n",
        "print(acc)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.812960235640648\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xZC7kjWt961H"
      },
      "source": [
        "#### tf-idf를 이용한 정확도 향상"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c2j7cZc71yiJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1cb2f6f-fb06-462d-eb9c-01b8fe08427f"
      },
      "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.fit_transform(x_test)\n",
        "\n",
        "NB.fit(x_train_tf, y_train)\n",
        "pred = NB.predict(x_test_tf)\n",
        "acc = accuracy_score(pred, y_test)\n",
        "print(acc)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8324005891016201\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1D0CGeJTA-ZH"
      },
      "source": [
        "### Support Vector Machine"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pbZx_Z7XIbhr"
      },
      "source": [
        "- 회귀, 분류, 이상치 탐지 등에 사용되는 지도학습 방법\n",
        "- 클래스 사이의 경계에 위치한 데이터 포인트를 서포트 벡터 라고 함\n",
        "- 각 서포트 벡터가 클래스 사이의 결정 경계를 구분하는데 얼마나 중요한지를 학습\n",
        "- 각 서포트 벡터 사이의 마진이 가장 큰 방향으로 학습\n",
        "- 서포트 벡터 까지의 거리와 서포트 벡터의 중요도를 기반으로 예측을 수행"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ogbxoPS0DMTd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "273511ab-0990-474f-94fe-8853e47f5a5e"
      },
      "source": [
        "from sklearn import svm\n",
        "\n",
        "SVM = svm.SVC(kernel='linear') #C 는 classification\n",
        "SVM.fit(x_train, y_train)\n",
        "pred = SVM.predict(x_test)\n",
        "acc = accuracy_score(pred, y_test)\n",
        "print(acc)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8247422680412371\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YPeounJWA-e6"
      },
      "source": [
        "### Decision Tree"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "62wyoby4EEDb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc5b76c9-fc96-4d08-efe4-5a54973df5cb"
      },
      "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(pred, y_test)\n",
        "print(acc)\n",
        "\n",
        "# 성능이 낮은 이유 : 데이터 셋이 인덱스여서 인덱스로 규칙을 찾기는 힘들 것이다."
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.6409425625920472\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UeEPOjxxA-my"
      },
      "source": [
        "### XGBoost"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tkKlfDHtH-SS"
      },
      "source": [
        "- 트리 기반의 앙상블 기법\n",
        "- 분류에 있어서 다른 알고리즘보다 좋은 예측 성능을 보여줌\n",
        "- XGBoost는 GBM 기반이지만, GBM의 단점인 느린 수행 시간과 과적합 규제 부재 등의 문제를 해결\n",
        "- 병렬 CPU 환경에서 빠르게 학습 가능"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4TAgLK5ECCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5edf6085-448e-4559-bde2-b27069befbd2"
      },
      "source": [
        "from xgboost import XGBClassifier\n",
        "\n",
        "xgb = XGBClassifier(n_estimators=30, learning_rate=0.5, max_depth=3)\n",
        "xgb.fit(x_train, y_train)\n",
        "pred = xgb.predict(x_test)\n",
        "acc = accuracy_score(pred, y_test)\n",
        "print(acc)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8094256259204713\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": "c309d196-a32e-4c71-cbee-75fcd00eabf1"
      },
      "source": [
        "# 나이브 베이즈 모델이 성능이 가장 좋았으므로, 이 모델로 교차검증 실행\n",
        "\n",
        "from sklearn.model_selection import cross_val_score\n",
        "\n",
        "scores = cross_val_score(NB, x, y, cv=5) #cv - 집합의 개수\n",
        "print(scores, scores.mean())"
      ],
      "execution_count": 14,
      "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": "eb832067-8da4-4ee3-f7e1-d9822d05a35c"
      },
      "source": [
        "from sklearn.metrics import precision_score, recall_score, f1_score\n",
        "\n",
        "precision = precision_score(pred, y_test, average='macro')\n",
        "recall = recall_score(pred, y_test, average='macro')\n",
        "f1 = f1_score(pred, y_test, average='macro')\n",
        "\n",
        "print(precision, recall, f1)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8063259489202534 0.8150749350762876 0.8093267187991195\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": "34f8c549-1020-4cbc-a3da-fa35f8b51c63"
      },
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "\n",
        "GS = GridSearchCV(estimator=NB, param_grid={'alpha': [0.001,0.01,0.1,1]}, scoring='accuracy', cv=10)\n",
        "GS.fit(x,y)\n",
        "\n",
        "print(GS.best_score_)\n",
        "print(GS.best_params_)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8897820965842167\n",
            "{'alpha': 0.001}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J6sko-naKpFm",
        "outputId": "4354be45-1898-47fe-d3e1-e690fc4d2d87"
      },
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "\n",
        "GS = GridSearchCV(estimator=NB, param_grid={'alpha': [0.0005,0.001,0.002,0.003,1]}, scoring='accuracy', cv=10)\n",
        "GS.fit(x,y)\n",
        "\n",
        "print(GS.best_score_)\n",
        "print(GS.best_params_)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8898702014852862\n",
            "{'alpha': 0.0005}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kAYQAWgCK7i6"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}