04-Model Experiments Mixed.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "\n",
    "from nltk.corpus import stopwords\n",
    "from matplotlib import pyplot\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
    "\n",
    "from sklearn.decomposition import PCA, TruncatedSVD\n",
    "from sklearn.metrics import f1_score, classification_report\n",
    "from sklearn.preprocessing import StandardScaler, Normalizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import cross_validate\n",
    "from scipy.special import logsumexp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"yelp_review_sentiment_2classes.tsv\", delimiter=\"\\t\")\n",
    "df = df.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression with Softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(z):\n",
    "    # Ensure numerical stability\n",
    "    exp_scores = np.exp(z - np.max(z, axis=1, keepdims=True))\n",
    "    return exp_scores / exp_scores.sum(1)[:, np.newaxis]\n",
    "\n",
    "def crossentropy(x, y):\n",
    "    m = (x * y).sum(1)\n",
    "    ce = np.log(m)\n",
    "    return -ce.sum()\n",
    "\n",
    "class SoftmaxRegression(object):\n",
    "    def __init__(self, w=None, b=None, lr=0.1, epochs=10):\n",
    "        self.lr = lr\n",
    "        self.epochs = epochs\n",
    "        self.w = w\n",
    "        self.b = b\n",
    "        self.label_bin = OneHotEncoder()\n",
    "\n",
    "    def get_params(self, deep=True):\n",
    "        # suppose this estimator has parameters \"alpha\" and \"recursive\"\n",
    "        return {\"w\": self.w, \"b\": self.b, \"lr\": self.lr, \"epochs\": self.epochs}\n",
    "\n",
    "    def set_params(self, **parameters):\n",
    "        for parameter, value in parameters.items():\n",
    "            setattr(self, parameter, value)\n",
    "        return self\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        y = np.asarray(self.label_bin.fit_transform(y.reshape(y.shape[0], 1)).todense())\n",
    "        limit = 1./np.sqrt(X.shape[1])\n",
    "        self.w = np.random.uniform(low=-limit, high=limit, size=(X.shape[1], y.shape[1]))\n",
    "        self.b = np.random.uniform(low=-limit, high=limit, size=(y.shape[1]))\n",
    "\n",
    "        for i in range(self.epochs):\n",
    "            z = X.dot(self.w) + self.b\n",
    "            z = softmax(z)\n",
    "            loss = crossentropy(z, y)\n",
    "\n",
    "            # Calculate gradients\n",
    "            dW = (X.T.dot(z - y) / X.shape[0])\n",
    "            db = z.sum(0) / X.shape[0]\n",
    "\n",
    "            self.w = self.w - self.lr * dW\n",
    "            self.b = self.b - self.lr * db\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        z = X.dot(self.w) + self.b\n",
    "        z = softmax(z)\n",
    "        return z\n",
    "    \n",
    "    def predict(self, X):\n",
    "        return self.predict_proba(X).argmax(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NaiveBayesClassification(object):\n",
    "    def __init__(self):\n",
    "        self.label_bin = OneHotEncoder()\n",
    "\n",
    "    def get_params(self, deep=True):\n",
    "        # suppose this estimator has parameters \"alpha\" and \"recursive\"\n",
    "        return {}\n",
    "\n",
    "    def set_params(self, **parameters):\n",
    "        for parameter, value in parameters.items():\n",
    "            setattr(self, parameter, value)\n",
    "        return self\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        _y = np.asarray(self.label_bin.fit_transform(y.reshape(y.shape[0], 1)).todense())\n",
    "        num_class = np.unique(y).shape[0]\n",
    "\n",
    "        self.prior = np.zeros((num_class))\n",
    "        for i in range(num_class):\n",
    "            self.prior[i] = (y == 1).sum() / y.shape[0]\n",
    "        self.log_prior = np.log(self.prior)\n",
    "\n",
    "        sum_words = (_y.T @ X) + 1\n",
    "        total_words = sum_words.sum()\n",
    "        self.log_likelihood = np.log(sum_words) - np.log(total_words)\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        llh = X @ self.log_likelihood.T\n",
    "        posterior = llh + self.log_prior\n",
    "        # Normalized by Z but in logarithmic form\n",
    "        posterior = posterior - logsumexp(posterior, axis=1).reshape(-1, 1)\n",
    "        return np.exp(posterior)\n",
    "\n",
    "    def predict(self, X):\n",
    "        preds = self.predict_proba(X)\n",
    "        return preds.argmax(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_stopwords = stopwords.words('english') + [\"-PRON-\", \"-pron-\", \"PRON\", \"pron\"]\n",
    "\n",
    "cnt_vec = CountVectorizer(ngram_range=(1, 3), min_df=10, stop_words=en_stopwords)\n",
    "tfidf_vec = TfidfVectorizer(ngram_range=(1, 3), min_df=10, stop_words=en_stopwords)\n",
    "label_enc = LabelEncoder()\n",
    "normalizer = Normalizer()\n",
    "pca_cnt = TruncatedSVD(300)\n",
    "pca_tfidf = TruncatedSVD(300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TruncatedSVD(n_components=300)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train, test = train_test_split(df, test_size=0.1, shuffle=True, random_state=42)\n",
    "\n",
    "cnt_vec.fit(train[\"text\"])\n",
    "tfidf_vec.fit(train[\"text\"])\n",
    "label_enc.fit(train[\"sentiment\"])\n",
    "\n",
    "pca_cnt.fit(cnt_vec.transform(train[\"text\"]))\n",
    "pca_tfidf.fit(tfidf_vec.transform(train[\"text\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prepare data to train..\n",
      "Cross-validate SoftmaxRegression-CountVectorizer-None-None\n",
      "SoftmaxRegression-CountVectorizer-None-None {'fit_time': array([379.01213384, 378.09152508, 376.1253531 , 377.24540901,\n",
      "       377.73758197]), 'score_time': array([0.22794223, 0.27637601, 0.28428793, 0.26222086, 0.26799893]), 'test_f1_micro': array([0.91574807, 0.91694817, 0.91719264, 0.91465908, 0.91648147]), 'train_f1_micro': array([0.92111521, 0.92119299, 0.92070406, 0.92135412, 0.9213819 ]), 'test_precision_micro': array([0.91574807, 0.91694817, 0.91719264, 0.91465908, 0.91648147]), 'train_precision_micro': array([0.92111521, 0.92119299, 0.92070406, 0.92135412, 0.9213819 ]), 'test_recall_micro': array([0.91574807, 0.91694817, 0.91719264, 0.91465908, 0.91648147]), 'train_recall_micro': array([0.92111521, 0.92119299, 0.92070406, 0.92135412, 0.9213819 ])}\n",
      "\n",
      "Prepare data to train..\n",
      "Cross-validate SoftmaxRegression-TfidfVectorizer-None-None\n",
      "SoftmaxRegression-TfidfVectorizer-None-None {'fit_time': array([284.91734791, 286.06731701, 285.36712098, 286.06955504,\n",
      "       285.0696919 ]), 'score_time': array([0.24377203, 0.16496205, 0.28284693, 0.15651703, 0.24170184]), 'test_f1_micro': array([0.8572762 , 0.86000978, 0.85949862, 0.85789848, 0.86125433]), 'train_f1_micro': array([0.86073762, 0.86010423, 0.86106543, 0.86097098, 0.86008756]), 'test_precision_micro': array([0.8572762 , 0.86000978, 0.85949862, 0.85789848, 0.86125433]), 'train_precision_micro': array([0.86073762, 0.86010423, 0.86106543, 0.86097098, 0.86008756]), 'test_recall_micro': array([0.8572762 , 0.86000978, 0.85949862, 0.85789848, 0.86125433]), 'train_recall_micro': array([0.86073762, 0.86010423, 0.86106543, 0.86097098, 0.86008756])}\n",
      "\n",
      "Prepare data to train..\n",
      "Cross-validate SoftmaxRegression-CountVectorizer-Normalizer-None\n",
      "SoftmaxRegression-CountVectorizer-Normalizer-None {'fit_time': array([257.92351389, 257.64900208, 257.47030997, 257.95966601,\n",
      "       256.76458907]), 'score_time': array([0.16392684, 0.15313387, 0.16152   , 0.15673184, 0.06604075]), 'test_f1_micro': array([0.84307494, 0.84436394, 0.84145257, 0.84118588, 0.84325273]), 'train_f1_micro': array([0.84283603, 0.84255267, 0.84374722, 0.84376389, 0.84297493]), 'test_precision_micro': array([0.84307494, 0.84436394, 0.84145257, 0.84118588, 0.84325273]), 'train_precision_micro': array([0.84283603, 0.84255267, 0.84374722, 0.84376389, 0.84297493]), 'test_recall_micro': array([0.84307494, 0.84436394, 0.84145257, 0.84118588, 0.84325273]), 'train_recall_micro': array([0.84283603, 0.84255267, 0.84374722, 0.84376389, 0.84297493])}\n",
      "\n",
      "Prepare data to train..\n",
      "Cross-validate SoftmaxRegression-TfidfVectorizer-Normalizer-None\n",
      "SoftmaxRegression-TfidfVectorizer-Normalizer-None {'fit_time': array([227.47166419, 226.66130829, 227.28164315, 227.8567121 ,\n",
      "       227.47604108]), 'score_time': array([0.08218598, 0.16492701, 0.16373086, 0.12037587, 0.13720894]), 'test_f1_micro': array([0.85720953, 0.86025424, 0.85952085, 0.85814295, 0.86147658]), 'train_f1_micro': array([0.86059872, 0.86013201, 0.86103765, 0.86079874, 0.8600709 ]), 'test_precision_micro': array([0.85720953, 0.86025424, 0.85952085, 0.85814295, 0.86147658]), 'train_precision_micro': array([0.86059872, 0.86013201, 0.86103765, 0.86079874, 0.8600709 ]), 'test_recall_micro': array([0.85720953, 0.86025424, 0.85952085, 0.85814295, 0.86147658]), 'train_recall_micro': array([0.86059872, 0.86013201, 0.86103765, 0.86079874, 0.8600709 ])}\n",
      "\n",
      "Prepare data to train..\n",
      "Cross-validate SoftmaxRegression-CountVectorizer-None-TruncatedSVD\n",
      "SoftmaxRegression-CountVectorizer-None-TruncatedSVD {'fit_time': array([157.016222  , 157.2449007 , 157.64493203, 157.89793992,\n",
      "       157.41238284]), 'score_time': array([0.16838694, 0.16176724, 0.14883995, 0.13449883, 0.16362429]), 'test_f1_micro': array([0.89305716, 0.89383501, 0.89312383, 0.88976798, 0.89450173]), 'train_f1_micro': array([0.89379612, 0.89360721, 0.89349053, 0.8943795 , 0.8931405 ]), 'test_precision_micro': array([0.89305716, 0.89383501, 0.89312383, 0.88976798, 0.89450173]), 'train_precision_micro': array([0.89379612, 0.89360721, 0.89349053, 0.8943795 , 0.8931405 ]), 'test_recall_micro': array([0.89305716, 0.89383501, 0.89312383, 0.88976798, 0.89450173]), 'train_recall_micro': array([0.89379612, 0.89360721, 0.89349053, 0.8943795 , 0.8931405 ])}\n",
      "\n",
      "Prepare data to train..\n",
      "Cross-validate SoftmaxRegression-TfidfVectorizer-None-TruncatedSVD\n",
      "SoftmaxRegression-TfidfVectorizer-None-TruncatedSVD {'fit_time': array([166.88559103, 167.24174118, 167.15524673, 167.1379447 ,\n",
      "       167.06818891]), 'score_time': array([0.15699291, 0.10180688, 0.13115907, 0.12122536, 0.1419332 ]), 'test_f1_micro': array([0.85389812, 0.8559872 , 0.85476487, 0.85189795, 0.85596497]), 'train_f1_micro': array([0.85617055, 0.85504267, 0.85530936, 0.85315361, 0.85400369]), 'test_precision_micro': array([0.85389812, 0.8559872 , 0.85476487, 0.85189795, 0.85596497]), 'train_precision_micro': array([0.85617055, 0.85504267, 0.85530936, 0.85315361, 0.85400369]), 'test_recall_micro': array([0.85389812, 0.8559872 , 0.85476487, 0.85189795, 0.85596497]), 'train_recall_micro': array([0.85617055, 0.85504267, 0.85530936, 0.85315361, 0.85400369])}\n",
      "\n",
      "Prepare data to train..\n",
      "Cross-validate NaiveBayesClassification-CountVectorizer-None-None\n",
      "NaiveBayesClassification-CountVectorizer-None-None {'fit_time': array([0.71666002, 0.7008481 , 0.66107583, 0.68356991, 0.66046309]), 'score_time': array([0.15196896, 0.15113974, 0.15153503, 0.15454912, 0.16325569]), 'test_f1_micro': array([0.83300738, 0.83574095, 0.83654103, 0.83280736, 0.83425193]), 'train_f1_micro': array([0.8476809 , 0.84871433, 0.85032558, 0.85009779, 0.84922549]), 'test_precision_micro': array([0.83300738, 0.83574095, 0.83654103, 0.83280736, 0.83425193]), 'train_precision_micro': array([0.8476809 , 0.84871433, 0.85032558, 0.85009779, 0.84922549]), 'test_recall_micro': array([0.83300738, 0.83574095, 0.83654103, 0.83280736, 0.83425193]), 'train_recall_micro': array([0.8476809 , 0.84871433, 0.85032558, 0.85009779, 0.84922549])}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "logistic = SoftmaxRegression(lr=0.5, epochs=500)\n",
    "nb = NaiveBayesClassification()\n",
    "\n",
    "\n",
    "combinations = [\n",
    "    (logistic, cnt_vec, None, None),\n",
    "    (logistic, tfidf_vec, None, None),\n",
    "    (logistic, cnt_vec, normalizer, None),\n",
    "    (logistic, tfidf_vec, normalizer, None),\n",
    "    (logistic, cnt_vec, None, pca_cnt),\n",
    "    (logistic, tfidf_vec, None, pca_tfidf),\n",
    "    (nb, cnt_vec, None, None)\n",
    "]\n",
    "\n",
    "res = {}\n",
    "for comb in combinations:\n",
    "    model = comb[0]\n",
    "    model_name = type(model).__name__\n",
    "    \n",
    "    print(\"Prepare data to train..\")\n",
    "    featurizer = comb[1]\n",
    "    featurizer_name = type(featurizer).__name__\n",
    "    X_train = featurizer.transform(train[\"text\"])\n",
    "    y_train = label_enc.transform(train[\"sentiment\"])\n",
    "    # X_test = featurizer.transform(test[\"text\"])\n",
    "    # y_test = label_enc.transform(test[\"sentiment\"])\n",
    "    \n",
    "    normalizer_name = \"None\"\n",
    "    if comb[2]:\n",
    "        normalizer = comb[2]\n",
    "        normalizer_name = type(normalizer).__name__\n",
    "        X_train = normalizer.fit_transform(X_train)\n",
    "        # X_test = normalizer.transform(X_test)\n",
    "        \n",
    "    decomposer_name = \"None\"\n",
    "    if comb[3]:\n",
    "        decomposer = comb[3]\n",
    "        decomposer = comb[3]\n",
    "        decomposer_name = type(decomposer).__name__\n",
    "        X_train = decomposer.transform(X_train)\n",
    "        # X_test = decomposer.transform(X_test)\n",
    "        \n",
    "    metadata = model_name + \"-\" + featurizer_name + \"-\" + normalizer_name + \"-\" + decomposer_name\n",
    "    \n",
    "    print(\"Cross-validate {}\".format(metadata))\n",
    "    score = cross_validate(model, X_train, y_train,\n",
    "                           scoring=[\"f1_micro\", \"precision_micro\", \"recall_micro\"],\n",
    "                           cv=5, n_jobs=-1, return_train_score=True)\n",
    "    res[metadata] = score\n",
    "    print(metadata, score)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis_df = pd.DataFrame()\n",
    "for k, v in res.items():\n",
    "    tmp_df = pd.DataFrame.from_dict(res[k])\n",
    "    tmp_df[\"meta\"] = k\n",
    "    \n",
    "    analysis_df = pd.concat([analysis_df, tmp_df])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8, 0.95)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(font_scale=1.5)\n",
    "a4_dims = (10, 7)\n",
    "fig, ax = pyplot.subplots(figsize=a4_dims)\n",
    "g = sns.boxplot(data=analysis_df, x=\"test_f1_micro\", y=\"meta\")\n",
    "g.set_xlim([0.8, 0.95])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis_df.to_csv(\"scratch_performance.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}