nlp_from_scratch_3cat.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.svm import SVC\n",
    "from nltk.stem.snowball import SnowballStemmer\n",
    "import nltk\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_path = './archive/train.csv'\n",
    "data_column  = 'tweet'\n",
    "SVM\t\t\t = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(dataset_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduce_repetition(s):\n",
    "    # Use regular expression to find repeated substrings\n",
    "    pattern = re.compile(r'(.+?)\\1{%d,}' % 2)\n",
    "    match = pattern.search(s)\n",
    "\n",
    "    # Reduce repetition to two occurrences\n",
    "    while match:\n",
    "        repeated_substring = match.group(1)\n",
    "        s = s.replace(match.group(), repeated_substring, 1)\n",
    "        match = pattern.search(s)\n",
    "\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "abbr = {\n",
    "    'ninstagram'        : 'instagram',\n",
    "    'instagramgram'     : 'instagram',\n",
    "    'ig'                : 'instagram',\n",
    "    'strainstagramht'   : 'instagram',\n",
    "    'insta'             : 'instagram',\n",
    "    'rinstagramht'      : 'instagram',\n",
    "    'ninstagramguh'     : 'instagram',\n",
    "    'instagramz'        : 'instagram',\n",
    "    'sinstagramn'       : 'instagram',\n",
    "    'binstagramgest'    : 'instagram',\n",
    "    'pinstagram'        : 'instagram',\n",
    "    'linstagramht'      : 'instagram',\n",
    "    'ninstagramg'       : 'instagram',\n",
    "    'instagramh'        : 'instagram',\n",
    "    'instagramnor'      : 'instagram',\n",
    "    'ninstagramht'      : 'instagram',\n",
    "    'ninstagramgramga'  : 'instagram',\n",
    "    'finstagramht'      : 'instagram',\n",
    "    'binstagram'        : 'instagram',\n",
    "    'hinstagramh'       : 'instagram',\n",
    "    'ninstagramga'      : 'instagram',\n",
    "    'toninstagramht'    : 'instagram',\n",
    "    'minstagramht'      : 'instagram',\n",
    "    'minstagramt'       : 'instagram',\n",
    "    'dwn'               : 'down',\n",
    "    'dawn'              : 'down',\n",
    "    'ta'                : 'that',\n",
    "    'dat'               : 'that',\n",
    "    'dawg'              : 'dude',\n",
    "    'smh'               : 'head',\n",
    "    'fr'                : 'real',\n",
    "    'plz'               : 'please',\n",
    "    'tf'                : 'wtf',\n",
    "    'theyr'             : 'are',\n",
    "    'bc'                : 'because',\n",
    "    'af'                : 'lot',\n",
    "    'u'                 : 'you',\n",
    "    'ppl'               : 'people',\n",
    "    'dm'                : 'message',\n",
    "    'bf'                : 'friend',\n",
    "    'gt'                : 'getting',\n",
    "    'ya'                : 'yes',\n",
    "    'na'                : 'no',\n",
    "    'ur'                : 'your',\n",
    "    'tryna'             : 'to',\n",
    "    'lmfao'             : 'lmao',\n",
    "    'ive'               : 'have'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_points(line):\n",
    "    l = list(line)\n",
    "\n",
    "    for i in range(len(l)):\n",
    "        if i < len(l) - 2 and l[i] == '.' and 'A' <= l[i+2] <= 'Z':\n",
    "            l[i] = ' '\n",
    "\n",
    "    line = ' '.join(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "stemmer = SnowballStemmer('english')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(sentence, get='sentence'):\n",
    "    sent = re.sub(r'@([a-zA-Z0-9_]+)', 'username', sentence).replace('username:', '') # replace first username\n",
    "    sent = re.sub(r'http?://\\S+', 'weblink', sent)\n",
    "    sent = re.sub(r'&amp', '&', sent)\n",
    "\n",
    "    if sent and sent[0] == '.':\n",
    "        sent = sent[1:]\n",
    "\n",
    "    remove_points(sent)\n",
    "    sent = sent   .replace('RT', '').replace('!', ' ').replace('\"', '').replace(\"\\n\", ' ')\\\n",
    "                        .replace(';', ' ').replace('-', ' ').replace(' and ', ' & ').replace('\\'', '')\\\n",
    "                        .replace('?', '.').replace(',', '').replace('~', ' ').replace('|', ' ').replace('°', ' ')\\\n",
    "                        .replace('`', ' ').replace('~', ' ').replace('*', ' ').replace('+', ' ').replace('/', ' ')\\\n",
    "                        .replace(' # ', ' ').replace('http', ' ').replace('t.co', ' ').replace('\\\\', ' ').replace('&#', ' ')\n",
    "    for _ in range(4):\n",
    "        sent = sent.replace('  ', ' ').replace('..', '.').replace(' .', '.') # remove multiple points & space\n",
    "    \n",
    "    if sent and sent[0] == ' ':\n",
    "        sent = sent[1:]\n",
    "\n",
    "    sent = sent.lower()\n",
    "\n",
    "    for old in abbr:\n",
    "        new = abbr[old]\n",
    "        sent = sent.replace( ' ' + old + ' ', ' ' + new + ' ' ) # add some space arround the world to avoid matching a part of a word\n",
    "\n",
    "    sent = reduce_repetition(sent)\n",
    "\n",
    "    if get == 'sentence':\n",
    "        return sent\n",
    "    \n",
    "    tokens = nltk.word_tokenize(sent)\n",
    "\n",
    "    for i in range(len(tokens) - 1, 0, -1):\n",
    "        if len(tokens[i].strip()) == 0 or (len(tokens[i].strip()) == 1 and tokens[i].strip() != 'a' and tokens[i].strip() != 'i' and tokens[i].strip() != '&'):\n",
    "            tokens.pop(i)\n",
    "\n",
    "    if get == 'tokens':\n",
    "        return tokens\n",
    "\n",
    "    stems = []\n",
    "\n",
    "    for tok in tokens:\n",
    "        stems.append(stemmer.stem(tok))\n",
    "\n",
    "    for i in range(len(stems) - 1, 0, -1):\n",
    "        if len(stems[i].strip()) == 0:\n",
    "            stems.pop(i)\n",
    "        elif len(stems[i].strip()) == 1:\n",
    "            if 'a' < stems[i].strip() <= 'z'and stems[i].strip() != 'i':\n",
    "                stems.pop(i)\n",
    "\n",
    "\n",
    "    for i in range(len(stems) - 1, 0, -1):\n",
    "        arr = stems[i].split('.')\n",
    "        stems[i] = arr[0]\n",
    "        for j in range(1, len(arr)):\n",
    "            stems.insert(i+j, arr[j])\n",
    "\n",
    "    for i in range(len(stems)):\n",
    "        if stems[i] in abbr.keys():\n",
    "            stems[i] = abbr[stems[i]]\n",
    "\n",
    "    return stems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['processed_text'] = df[data_column].apply(preprocess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_vectorizer = TfidfVectorizer(max_features=5000)\n",
    "X_tfidf = tfidf_vectorizer.fit_transform(df['processed_text']).toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def label_tweet(row):\n",
    "    \"\"\"\n",
    "    - Hate: If hate_speech_count is the highest count.\n",
    "    - Offensive: If offensive_language_count is the highest count.\n",
    "    - Hate & Offensive: If hate_speech_count and offensive_language_count are equal and higher than neither_count.\n",
    "    - Neither: If neither_count is the highest count.\n",
    "    \"\"\"\n",
    "    if row['hate_speech_count'] > row['offensive_language_count'] and row['hate_speech_count'] > row['neither_count']:\n",
    "        return 'hate'\n",
    "    elif row['offensive_language_count'] > row['hate_speech_count'] and row['offensive_language_count'] > row['neither_count']:\n",
    "        return 'offensive'\n",
    "    elif row['hate_speech_count'] == row['offensive_language_count'] and row['hate_speech_count'] > row['neither_count']:\n",
    "        return 'hate_offensive'\n",
    "    else:\n",
    "        return 'neither'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['label'] = df.apply(label_tweet, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_encoder = LabelEncoder()\n",
    "y = label_encoder.fit_transform(df['label'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hate': 0, 'neither': 1, 'offensive': 2}\n"
     ]
    }
   ],
   "source": [
    "label_mapping = dict(zip(label_encoder.classes_, label_encoder.transform(label_encoder.classes_)))\n",
    "print(label_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X_tfidf, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Logistic Regression** Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression(max_iter=1000)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(max_iter=1000)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "LogisticRegression(max_iter=1000)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logistic_model = LogisticRegression(max_iter=1000)\n",
    "logistic_model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "logistic_predictions = logistic_model.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SVM** Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "if SVM:\n",
    "\tsvm_model = SVC()\n",
    "\tsvm_model.fit(X_train, y_train)\n",
    "\tsvm_predictions = svm_model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluation function\n",
    "def evaluate_model(y_true, y_pred):\n",
    "    accuracy = accuracy_score(y_true, y_pred)\n",
    "    precision = precision_score(y_true, y_pred, average='weighted')\n",
    "    recall = recall_score(y_true, y_pred, average='weighted')\n",
    "    f1 = f1_score(y_true, y_pred, average='weighted')\n",
    "    return accuracy, precision, recall, f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression - Accuracy: 0.89, Precision: 0.88, Recall: 0.89, F1 Score: 0.88\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the models\n",
    "logistic_eval = evaluate_model(y_test, logistic_predictions)\n",
    "if SVM: svm_eval = evaluate_model(y_test, svm_predictions)\n",
    "\n",
    "print(\"Logistic Regression - Accuracy: {:.2f}, Precision: {:.2f}, Recall: {:.2f}, F1 Score: {:.2f}\".format(*logistic_eval))\n",
    "if SVM: print(\"SVM - Accuracy: {:.2f}, Precision: {:.2f}, Recall: {:.2f}, F1 Score: {:.2f}\".format(*svm_eval))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in np.ndindex(cm.shape):\n",
    "        plt.text(\tj, i, format(cm[i, j], fmt),\n",
    "\t\t\t\t\thorizontalalignment=\"center\",\n",
    "\t\t\t\t\tcolor=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(y_test, logistic_predictions, classes=label_mapping.keys(), normalize=True, title='logistic regression confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "if SVM: plot_confusion_matrix(y_test, svm_predictions, classes=['1', '2', '3'], normalize=True, title='SVM confusion matrix')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}