machine_forgetting_challenge.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import sys \n",
    "import pandas as pd\n",
    "import sklearn\n",
    "import re\n",
    "import string\n",
    "from sklearn.datasets import fetch_20newsgroups\n",
    "from collections import defaultdict\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.corpus import names\n",
    "from nltk.stem import PorterStemmer\n",
    "import numpy as np\n",
    "import nltk\n",
    "from nltk.corpus import wordnet \n",
    "import pandas as pd\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import SnowballStemmer\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "import seaborn as sns\n",
    "from sklearn.feature_extraction.text import CountVectorizer \n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import classification_report  \n",
    "from sklearn import preprocessing\n",
    "#from gensim.models import Word2Vec\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import classification_report\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "\n",
    "ps = PorterStemmer()\n",
    "all_names = names.words()\n",
    "WNL = WordNetLemmatizer()\n",
    "basic_stopwords = stopwords.words('english')\n",
    "wordnet_lemmatizer = WordNetLemmatizer()\n",
    "snowball_stemmer = SnowballStemmer('english') \n",
    "basic_stopwords = stopwords.words('english') \n",
    "punctuation = string.punctuation\n",
    "lemmatizer = WordNetLemmatizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "def clean_data(df):\n",
    "    #df.data =df.data.replace(to_replace='From:(.*\\n)', value='', regex=True) ##remove from to email\n",
    "    df.data =df.data.replace(to_replace='lines:(.*\\n)', value='', regex=True)\n",
    "    #df.data =df.data.replace(to_replace='Subject:(.*\\n)', value='', regex=True)#remove subject\n",
    "    df.data =df.data.replace(to_replace='[!\"#$%&\\'()*+,/:;<=>?@[\\\\]^_`{|}~]', value=' ', regex=True) #remove punctuation\n",
    "    df.data =df.data.replace(to_replace='-', value=' ', regex=True)\n",
    "    df.data =df.data.replace(to_replace='\\s+', value=' ', regex=True)    #remove new line\n",
    "    df.data =df.data.replace(to_replace='  ', value='', regex=True)                #remove double white space\n",
    "    df.data = df.data.replace('((www.[^s]+)|(https?://[^s]+))',value='',regex=True)\n",
    "    df.data = df.data.replace(r\"@\\S+\",value='', regex=True)                \n",
    "    df.data = df.data.replace(r\"\\b[a-zA-Z]{1,2}\\b\", value=\"\", regex=True)  \n",
    "    df.data =df.data.apply(lambda x:x.strip())  # ltrim and ltrim of whitespace \n",
    "    df['data']=[entry.lower() for entry in df['data']] #to lowercase\n",
    "    return df  \n",
    "\n",
    "def custom_lemmatizer(word, pos_tag): #takes as argument the word and the pos tag\n",
    "    if pos_tag.startswith(\"N\"):\n",
    "        word = wordnet_lemmatizer.lemmatize(word, wordnet.NOUN)\n",
    "        return (word)\n",
    "    elif pos_tag.startswith('V'):\n",
    "        word = wordnet_lemmatizer.lemmatize(word, wordnet.VERB)\n",
    "        return (word)\n",
    "    elif pos_tag.startswith('J'):\n",
    "        word = wordnet_lemmatizer.lemmatize(word, wordnet.ADJ)\n",
    "        return (word)\n",
    "    elif pos_tag.startswith('R'):\n",
    "        word = wordnet_lemmatizer.lemmatize(word, wordnet.ADV)\n",
    "        return (word)\n",
    "    else:\n",
    "        return word\n",
    "    \n",
    "def freq_words(text):\n",
    "    # tokenization\n",
    "    counter = Counter() \n",
    "    tokens = nltk.word_tokenize(text)\n",
    "    for word in tokens:\n",
    "        counter[word]= +1\n",
    "\n",
    "    FrequentWords = []\n",
    "    number_freq_words = 5\n",
    "    for (word, word_count) in counter.most_common(number_freq_words):\n",
    "            FrequentWords.append(word)\n",
    "\n",
    "    return FrequentWords\n",
    "\n",
    "def remove_fw(text, FrequentWords):\n",
    "    tokens = nltk.word_tokenize(text)\n",
    "    without_fw = []\n",
    "    for word in tokens:\n",
    "        if word not in FrequentWords:\n",
    "            without_fw.append(word)\n",
    "\n",
    "    without_fw = ' '.join(without_fw)\n",
    "    return without_fw\n",
    "        \n",
    "def rare_words(text):\n",
    "    # tokenization\n",
    "    counter = Counter() \n",
    "    tokens = nltk.word_tokenize(text)\n",
    "    for word in tokens:\n",
    "        counter[word]= +1\n",
    "    RareWords = []\n",
    "    number_rare_words = 5\n",
    "        # take top 10 frequent words\n",
    "    frequentWords = counter.most_common() \n",
    "    for (word, word_count) in frequentWords[:-number_rare_words:-1]:\n",
    "        RareWords.append(word)\n",
    "    return RareWords\n",
    "\n",
    "def remove_rw(text, RareWords): \n",
    "    tokens = nltk.word_tokenize(text)\n",
    "    without_rw = []\n",
    "    for word in tokens:\n",
    "        if word not in RareWords:\n",
    "            without_rw.append(word)\n",
    "\n",
    "    without_rw = ' '.join(without_fw)\n",
    "    return without_rw\n",
    "\n",
    "\n",
    "def custom_preprocess(data, remove_rare = False):\n",
    "    \n",
    "    data = nltk.word_tokenize(data)\n",
    "    remove_punctuation = str.maketrans('', '', punctuation)\n",
    "    data = [word.translate(remove_punctuation) for word in data if word not in basic_stopwords ]#and word.isalnum()] #and not word.isdigit()]\n",
    "    data = [lemmatizer.lemmatize(word) for word in data]\n",
    "    tagged_data = nltk.pos_tag(data)\n",
    "    data = [custom_lemmatizer(word[0],word[1]) for word in tagged_data] \n",
    "    data = ' '.join(data)  \n",
    "    if remove_rare is True:\n",
    "        RareWords = rare_words(data)\n",
    "        data = remove_fw(data, RareWords)\n",
    "        FrequentWords = freq_words(data) \n",
    "        data = remove_fw(data, FrequentWords)\n",
    "    return data\n",
    "\n",
    "def get_synonyms(word):\n",
    "    synonyms = set()\n",
    "    \n",
    "    for syn in wordnet.synsets(word): \n",
    "        for l in syn.lemmas(): \n",
    "            synonym = l.name().replace(\"_\", \" \").replace(\"-\", \" \").lower()\n",
    "            synonym = \"\".join([char for char in synonym if char in ' qwertyuiopasdfghjklzxcvbnm'])\n",
    "            synonyms.add(synonym) \n",
    "    \n",
    "    if word in synonyms:\n",
    "        synonyms.remove(word)\n",
    "    \n",
    "    return list(synonyms)\n",
    "\n",
    "def synonym_replacement(words, n):\n",
    "\n",
    "    words = words.split()\n",
    "\n",
    "    new_words = words.copy()\n",
    "    random_word_list = list(set([word for word in words if word not in basic_stopwords]))\n",
    "    random.shuffle(random_word_list)\n",
    "    num_replaced = 0\n",
    "\n",
    "    for random_word in random_word_list:\n",
    "        synonyms = get_synonyms(random_word)\n",
    "        \n",
    "        if len(synonyms) >= 1:\n",
    "            synonym = random.choice(list(synonyms))\n",
    "            new_words = [synonym if word == random_word else word for word in new_words]\n",
    "            num_replaced += 1\n",
    "        \n",
    "        if num_replaced >= n: #only replace up to n words\n",
    "            break\n",
    "\n",
    "    sentence = ' '.join(new_words)\n",
    "\n",
    "    return sentence\n",
    "\n",
    "def DataAugmentation(train_df):\n",
    "    tmp_df = pd.DataFrame()\n",
    "    for doc in range(0,len(train_df)):\n",
    "        tmp1 = pd.DataFrame()\n",
    "        label = train_df.target.iloc[doc]\n",
    "        length = len(train_df.data.iloc[doc])\n",
    "        tmp1 = pd.DataFrame(#creating a temporary dataframe to store the current data and target\n",
    "                    {\n",
    "                        'data':synonym_replacement(train_df.data.iloc[doc], length/6),\n",
    "                        'target':label\n",
    "                    },index=[0])\n",
    "        tmp_df = pd.concat([tmp_df,tmp1])\n",
    "    return pd.concat([train_df,tmp_df])\n",
    "\n",
    "\n",
    "def model_Evaluate(model,y_test,x_test):\n",
    "    y_pred = model.predict(x_test)\n",
    "    print(classification_report(y_test, y_pred)) \n",
    "    plot_confusion_matrix(model, x_test, y_test)  \n",
    "    plt.rcParams['figure.figsize'] = [20, 20] \n",
    "    plt.show()\n",
    "    \n",
    "def LR_Model(x_train,y_train,x_test,y_test):\n",
    "    LRmodel = LogisticRegression(max_iter = 1000, n_jobs=-1)\n",
    "    LRmodel.fit(x_train, y_train)\n",
    "    model_Evaluate(LRmodel,y_test,x_test)\n",
    "    y_pred3 = LRmodel.predict(x_test)\n",
    "\n",
    "def SGD_Model(x_train,y_train,x_test,y_test): \n",
    "    sgd_m = SGDClassifier(max_iter=2000,warm_start=True)\n",
    "    sgd_m.fit(x_train, y_train)\n",
    "    model_Evaluate(sgd_m,y_test,x_test)\n",
    "    \n",
    "def MNB_Model(x_train,y_train,x_test,y_test): \n",
    "    mnb_m = MultinomialNB(alpha=0.05)\n",
    "    mnb_m.fit(x_train, y_train)\n",
    "    model_Evaluate(mnb_m,y_test,x_test)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading, cleaning & preprocessing data\n",
    "train_data = fetch_20newsgroups(subset='train', shuffle=True, random_state=42) \n",
    "test_data = fetch_20newsgroups(subset='test')\n",
    "\n",
    "train_df = pd.DataFrame(data=train_data['data'],columns=['data'])\n",
    "train_df['target'] = pd.DataFrame(data=train_data['target'])\n",
    "\n",
    "test_df = pd.DataFrame(data=test_data['data'],columns=['data'])\n",
    "test_df['target'] = pd.DataFrame(data=test_data['target'])\n",
    "\n",
    "train_df = clean_data(train_df)\n",
    "train_df.data = train_df.data.apply(lambda x:custom_preprocess(x,False))\n",
    "test_df = clean_data(test_df)\n",
    "test_df.data = test_df.data.apply(lambda x:custom_preprocess(x,False))\n",
    "train_df = DataAugmentation(train_df)\n",
    "\n",
    "x_train = train_df.data\n",
    "y_train = train_df.target\n",
    "x_test = test_df.data\n",
    "y_test = test_df.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = train_df.data\n",
    "y_train = train_df.target\n",
    "x_test = test_df.data\n",
    "y_test = test_df.target\n",
    "ros = RandomOverSampler()\n",
    "\n",
    "vectorizer = TfidfVectorizer(max_features=100000)\n",
    "#vectorizer = CountVectorizer(stop_words='english') \n",
    "vectorizer.fit(x_train)\n",
    "print('No. of feature_words: ', len(vectorizer.get_feature_names_out()))\n",
    "x_train = vectorizer.transform(x_train)\n",
    "x_test = vectorizer.transform(x_test) \n",
    "\n",
    "le = preprocessing.LabelEncoder()\n",
    "train_df['target'] = le.fit_transform(train_df['target'])\n",
    "test_df['target']  = le.fit_transform(test_df['target'])\n",
    "\n",
    "x_train,y_train = ros.fit_resample(x_train,y_train)\n",
    "#sns.countplot(train_df['target'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 496,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.81      0.75      0.78       319\n",
      "           1       0.76      0.79      0.78       389\n",
      "           2       0.77      0.73      0.75       394\n",
      "           3       0.76      0.72      0.74       392\n",
      "           4       0.79      0.86      0.82       385\n",
      "           5       0.89      0.80      0.84       395\n",
      "           6       0.77      0.86      0.82       390\n",
      "           7       0.93      0.89      0.91       396\n",
      "           8       0.94      0.96      0.95       398\n",
      "           9       0.92      0.96      0.94       397\n",
      "          10       0.95      0.98      0.97       399\n",
      "          11       0.92      0.94      0.93       396\n",
      "          12       0.80      0.75      0.77       393\n",
      "          13       0.91      0.87      0.89       396\n",
      "          14       0.90      0.93      0.92       394\n",
      "          15       0.84      0.93      0.88       398\n",
      "          16       0.74      0.91      0.81       364\n",
      "          17       0.97      0.91      0.94       376\n",
      "          18       0.83      0.60      0.70       310\n",
      "          19       0.68      0.62      0.65       251\n",
      "\n",
      "    accuracy                           0.85      7532\n",
      "   macro avg       0.84      0.84      0.84      7532\n",
      "weighted avg       0.85      0.85      0.84      7532\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/tsac/.config/miniforge/envs/ml_env/lib/python3.8/site-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function plot_confusion_matrix is deprecated; Function `plot_confusion_matrix` is deprecated in 1.0 and will be removed in 1.2. Use one of the class methods: ConfusionMatrixDisplay.from_predictions or ConfusionMatrixDisplay.from_estimator.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "SGD_Model(x_train,y_train,x_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#LR_Model(x_train,y_train,x_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#MNB_Model(x_train,y_train,x_test,y_test)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}