TF-IDF_use_idf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dd490bc2-0b2b-4583-b01c-7db8a8632ba7",
   "metadata": {},
   "source": [
    "# TF-IDF: Use IDF"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "878db841-b044-482d-a455-6c82f8a552a9",
   "metadata": {},
   "source": [
    "This notebook examines the value of the use_idf parameter (where document frequency is accounted for) when using TF-IDF and a bagging classifier on a [Kaggle essay scores](https://www.kaggle.com/competitions/learning-agency-lab-automated-essay-scoring-2) dataset of ~17,000 essays. The results seem to suggest that adjusting the use_idf parameter doesn't make too much difference. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9b7c5264-5672-4de3-8dd1-7a446e67d466",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>essay_id</th>\n",
       "      <th>full_text</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>000d118</td>\n",
       "      <td>Many people have car where they live. The thin...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000fe60</td>\n",
       "      <td>I am a scientist at NASA that is discussing th...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>001ab80</td>\n",
       "      <td>People always wish they had the same technolog...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>001bdc0</td>\n",
       "      <td>We all heard about Venus, the planet without a...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>002ba53</td>\n",
       "      <td>Dear, State Senator\\n\\nThis is a letter to arg...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  essay_id                                          full_text  score\n",
       "0  000d118  Many people have car where they live. The thin...      3\n",
       "1  000fe60  I am a scientist at NASA that is discussing th...      3\n",
       "2  001ab80  People always wish they had the same technolog...      4\n",
       "3  001bdc0  We all heard about Venus, the planet without a...      4\n",
       "4  002ba53  Dear, State Senator\\n\\nThis is a letter to arg...      3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "train = pd.read_csv('data/train.csv')\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69f5a768-ce73-4c9d-b813-8f629e18203d",
   "metadata": {},
   "source": [
    "## Preprocess Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "31635325-de28-4070-9d4d-78adc18ea79a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import string\n",
    "import nltk\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "\n",
    "def preprocess_text(text):\n",
    "\n",
    "    # removes unprintable characters\n",
    "    unprintable = r\"[^\\w\\s]\"\n",
    "    text = re.sub(unprintable, '', text)\n",
    "\n",
    "    # removes non-breaking space characters\n",
    "    non_breaking = '\\xa0'\n",
    "    text = re.sub(non_breaking, ' ', text)\n",
    "\n",
    "    # removes newline characters\n",
    "    newline = '\\n'\n",
    "    text = re.sub(newline, ' ', text)\n",
    "\n",
    "    # removes punctuation\n",
    "    text = text.translate(str.maketrans('', '', string.punctuation))\n",
    "    \n",
    "    # lowercase the text\n",
    "    text = text.lower()\n",
    "    \n",
    "    # tokenization\n",
    "    tokens = word_tokenize(text)\n",
    "    \n",
    "    # lemmatization\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    tokens = [lemmatizer.lemmatize(token) for token in tokens]\n",
    "    \n",
    "    # join tokens back into a string\n",
    "    preprocessed_text = ' '.join(tokens)\n",
    "    \n",
    "    return preprocessed_text\n",
    "\n",
    "train['full_text'] = [preprocess_text(x) for x in train['full_text']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7e4f658-9ddf-4d51-add2-11c766aff5a7",
   "metadata": {},
   "source": [
    "## Drop misspellings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "25ca1d1b-702c-4d75-b310-08e52cbdceaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "from spellchecker import SpellChecker\n",
    "\n",
    "# creates a spellckecker object\n",
    "spell = SpellChecker()\n",
    "\n",
    "# returns a count of misspelled words\n",
    "def misspellings(essay, drop=True):\n",
    "\n",
    "    # the essay is split into words\n",
    "    words = essay.split()\n",
    "\n",
    "    # either drops or corrects unknown words\n",
    "    final_words = []\n",
    "    if drop == True:\n",
    "        # loops through each word\n",
    "        for word in words:\n",
    "            \n",
    "            # checks if the word is known\n",
    "            if spell.known([word]):\n",
    "                \n",
    "                # appends to a list of words to return\n",
    "                final_words.append(word)\n",
    "    \n",
    "    else:\n",
    "        # loops through each word\n",
    "        for word in words:\n",
    "            \n",
    "            # checks if the word is known\n",
    "            if spell.known([word]):\n",
    "                \n",
    "                # appends to a list of words to return\n",
    "                final_words.append(word)\n",
    "\n",
    "            else:\n",
    "                # attempts to correct the word\n",
    "                correction = spell.correction(word)\n",
    "\n",
    "                # appends the correction if one was found\n",
    "                if correction != None:\n",
    "                    # appends to a list of words to return\n",
    "                    final_words.append(correction)\n",
    "\n",
    "    # joins the words back together with a space \n",
    "    return ' '.join(final_words)\n",
    "\n",
    "train['full_text'] = [misspellings(x) for x in train['full_text']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2398751a-51d9-4164-9378-0640f1c4b9c7",
   "metadata": {},
   "source": [
    "## Fit model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7b07babd-4a86-4990-8fbb-ab22f1384359",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Building estimator 1 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 2 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 3 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 4 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 5 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 6 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 7 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 8 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 9 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 10 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 1 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 2 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 3 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 4 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 5 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 6 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 7 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 8 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 9 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]Building estimator 10 of 10 for this parallel run (total 10)...\n",
      "[LibSVM]"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import BaggingClassifier  \n",
    "from sklearn.svm import SVC  \n",
    "from sklearn.metrics import cohen_kappa_score\n",
    "\n",
    "def fit_model(use_idf):\n",
    "\n",
    "    # a text vectorizer with a variable n-gram range is specified\n",
    "    text_vectorizer = TfidfVectorizer(\n",
    "    stop_words='english',\n",
    "    sublinear_tf=False,\n",
    "    strip_accents='unicode',\n",
    "    binary=True,\n",
    "    analyzer='word',\n",
    "    token_pattern=r'\\w{2,}',  \n",
    "    ngram_range=(1, 2),\n",
    "    norm='l1', \n",
    "    use_idf=use_idf, \n",
    "    smooth_idf=False,\n",
    "    max_features=100000,\n",
    "    min_df=30)\n",
    "\n",
    "    # vectorises the train text\n",
    "    x = text_vectorizer.fit_transform(train['full_text'])\n",
    "    y = train['score']\n",
    "\n",
    "    # splits the data into training and test sets\n",
    "    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=123)\n",
    "    \n",
    "    # fits a bagging model \n",
    "    model = BaggingClassifier(estimator=SVC(C=1.75, \n",
    "                                            kernel='rbf', \n",
    "                                            gamma='scale', \n",
    "                                            decision_function_shape='ovr', \n",
    "                                            random_state=123, \n",
    "                                            tol=1e-5, \n",
    "                                            shrinking=True, \n",
    "                                            verbose=True, \n",
    "                                            break_ties=True), \n",
    "                              n_estimators=10, \n",
    "                              random_state=123, \n",
    "                              verbose=3) \n",
    "    \n",
    "    model.fit(x_train, y_train.values.ravel())\n",
    "\n",
    "    # predicts test values\n",
    "    y_pred_bag = model.predict(x_test)\n",
    "\n",
    "    # evaluates predictions with the quadratic weighted Cohen Kappa\n",
    "    score = cohen_kappa_score(y_test.values.ravel(), y_pred_bag.ravel(), weights='quadratic')\n",
    "    \n",
    "    return score\n",
    "    \n",
    "# loops through each max feature, vectorising text, fitting a model and evaluating performance\n",
    "use_idfs = [True, False]\n",
    "averages = []\n",
    "for use_idf in use_idfs:\n",
    "    score = fit_model(use_idf)\n",
    "    averages.append(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe1772f-8a6d-4c9a-8454-6582e4ae462c",
   "metadata": {},
   "source": [
    "## Visualize results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "945e2c4e-5368-4f53-903b-286bb4af2168",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# plots the results\n",
    "use_idfs = ['True', 'False']\n",
    "plt.figure(figsize=(12, 6));\n",
    "plt.bar(use_idfs, averages);\n",
    "plt.xlabel('');\n",
    "plt.ylabel('Cohen Kappa Score');\n",
    "plt.title('Use IDF', size=30);\n",
    "plt.show();"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}