nlp-classification-shallow-learning-with-n-grams.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/kaggle/input/janata-hacknlp/sample_submission_wgBqZCk.csv\n",
      "/kaggle/input/janata-hacknlp/train_E52nqFa/game_overview.csv\n",
      "/kaggle/input/janata-hacknlp/train_E52nqFa/train.csv\n",
      "/kaggle/input/janata-hacknlp/test_BppAoe0/test.csv\n"
     ]
    }
   ],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import os\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "    for filename in filenames:\n",
    "        print(os.path.join(dirname, filename))\n",
    "        \n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import tensorflow as tf\n",
    "from sklearn import preprocessing, linear_model, ensemble, metrics, model_selection, svm, pipeline, naive_bayes\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer\n",
    "import nltk\n",
    "import spacy\n",
    "import textblob\n",
    "from nltk import word_tokenize          \n",
    "from nltk.stem import WordNetLemmatizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '\\\\kaggle\\\\input\\\\janata-hacknlp\\\\'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read Data\n",
    "train = pd.read_csv('/kaggle/input/janata-hacknlp/train_E52nqFa/train.csv')\n",
    "test = pd.read_csv('/kaggle/input/janata-hacknlp/test_BppAoe0/test.csv')\n",
    "meta = pd.read_csv('/kaggle/input/janata-hacknlp/train_E52nqFa/game_overview.csv')\n",
    "\n",
    "# Rename Certain columns\n",
    "train = train.rename({'year': 'year_no', 'title': 'title_no'}, axis = 1)\n",
    "test = test.rename({'year': 'year_no', 'title': 'title_no'}, axis = 1)\n",
    "meta = meta.rename({'title': 'title_no', 'developer': 'developer_no'}, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>review_id</th>\n",
       "      <th>title_no</th>\n",
       "      <th>year_no</th>\n",
       "      <th>user_review</th>\n",
       "      <th>user_suggestion</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Spooky's Jump Scare Mansion</td>\n",
       "      <td>2016.0</td>\n",
       "      <td>I'm scared and hearing creepy voices.  So I'll...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Spooky's Jump Scare Mansion</td>\n",
       "      <td>2016.0</td>\n",
       "      <td>Best game, more better than Sam Pepper's YouTu...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Spooky's Jump Scare Mansion</td>\n",
       "      <td>2016.0</td>\n",
       "      <td>A littly iffy on the controls, but once you kn...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Spooky's Jump Scare Mansion</td>\n",
       "      <td>2015.0</td>\n",
       "      <td>Great game, fun and colorful and all that.A si...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Spooky's Jump Scare Mansion</td>\n",
       "      <td>2015.0</td>\n",
       "      <td>Not many games have the cute tag right next to...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   review_id                     title_no  year_no  \\\n",
       "0          1  Spooky's Jump Scare Mansion   2016.0   \n",
       "1          2  Spooky's Jump Scare Mansion   2016.0   \n",
       "2          3  Spooky's Jump Scare Mansion   2016.0   \n",
       "3          4  Spooky's Jump Scare Mansion   2015.0   \n",
       "4          5  Spooky's Jump Scare Mansion   2015.0   \n",
       "\n",
       "                                         user_review  user_suggestion  \n",
       "0  I'm scared and hearing creepy voices.  So I'll...                1  \n",
       "1  Best game, more better than Sam Pepper's YouTu...                1  \n",
       "2  A littly iffy on the controls, but once you kn...                1  \n",
       "3  Great game, fun and colorful and all that.A si...                1  \n",
       "4  Not many games have the cute tag right next to...                1  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>title_no</th>\n",
       "      <th>developer_no</th>\n",
       "      <th>publisher</th>\n",
       "      <th>tags</th>\n",
       "      <th>overview</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Spooky's Jump Scare Mansion</td>\n",
       "      <td>Lag Studios</td>\n",
       "      <td>Lag Studios</td>\n",
       "      <td>['Horror', 'Free to Play', 'Cute', 'First-Pers...</td>\n",
       "      <td>Can you survive 1000 rooms of cute terror? Or ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Sakura Clicker</td>\n",
       "      <td>Winged Cloud</td>\n",
       "      <td>Winged Cloud</td>\n",
       "      <td>['Nudity', 'Anime', 'Free to Play', 'Mature', ...</td>\n",
       "      <td>The latest entry in the Sakura series is more ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>WARMODE</td>\n",
       "      <td>WARTEAM</td>\n",
       "      <td>WARTEAM</td>\n",
       "      <td>['Early Access', 'Free to Play', 'FPS', 'Multi...</td>\n",
       "      <td>Free to play shooter about the confrontation o...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Fractured Space</td>\n",
       "      <td>Edge Case Games Ltd.</td>\n",
       "      <td>Edge Case Games Ltd.</td>\n",
       "      <td>['Space', 'Multiplayer', 'Free to Play', 'PvP'...</td>\n",
       "      <td>Take the helm of a gigantic capital ship and g...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Counter-Strike: Global Offensive</td>\n",
       "      <td>Valve, Hidden Path Entertainment</td>\n",
       "      <td>Valve</td>\n",
       "      <td>['FPS', 'Multiplayer', 'Shooter', 'Action', 'T...</td>\n",
       "      <td>Counter-Strike: Global Offensive (CS: GO) expa...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           title_no                       developer_no  \\\n",
       "0       Spooky's Jump Scare Mansion                       Lag Studios    \n",
       "1                    Sakura Clicker                      Winged Cloud    \n",
       "2                           WARMODE                           WARTEAM    \n",
       "3                   Fractured Space              Edge Case Games Ltd.    \n",
       "4  Counter-Strike: Global Offensive  Valve, Hidden Path Entertainment    \n",
       "\n",
       "               publisher                                               tags  \\\n",
       "0           Lag Studios   ['Horror', 'Free to Play', 'Cute', 'First-Pers...   \n",
       "1          Winged Cloud   ['Nudity', 'Anime', 'Free to Play', 'Mature', ...   \n",
       "2               WARTEAM   ['Early Access', 'Free to Play', 'FPS', 'Multi...   \n",
       "3  Edge Case Games Ltd.   ['Space', 'Multiplayer', 'Free to Play', 'PvP'...   \n",
       "4                 Valve   ['FPS', 'Multiplayer', 'Shooter', 'Action', 'T...   \n",
       "\n",
       "                                            overview  \n",
       "0  Can you survive 1000 rooms of cute terror? Or ...  \n",
       "1  The latest entry in the Sakura series is more ...  \n",
       "2  Free to play shooter about the confrontation o...  \n",
       "3  Take the helm of a gigantic capital ship and g...  \n",
       "4  Counter-Strike: Global Offensive (CS: GO) expa...  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meta.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:13: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  del sys.path[0]\n"
     ]
    }
   ],
   "source": [
    "# Add Meta Data\n",
    "train = train.merge(meta, on = 'title_no')\n",
    "test = test.merge(meta, on = 'title_no')\n",
    "\n",
    "train_id = train.review_id\n",
    "test_id = test.review_id\n",
    "\n",
    "# Create indices to split train and test on later\n",
    "train['train_ind'] = np.arange(train.shape[0])\n",
    "test['train_ind'] = np.arange(train.shape[0], train.shape[0]+test.shape[0])\n",
    "\n",
    "# Merge Train and Test - This approach only works for competitions - not for model deployment in real projects.\n",
    "data = pd.concat([train, test], axis = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create a class to perform Label Encoding for multiple columns at the same time. It has transform attributes.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create class which performs Label Encoding - if required\n",
    "class categorical_encoder:\n",
    "    def __init__(self, columns, kind = 'label', fill = True):\n",
    "        self.kind = kind\n",
    "        self.columns = columns\n",
    "        self.fill = fill\n",
    "        \n",
    "    def fit(self, X):\n",
    "        self.dict = {}\n",
    "        self.fill_value = {}\n",
    "        \n",
    "        for col in self.columns:\n",
    "            label = preprocessing.LabelEncoder().fit(X[col])\n",
    "            self.dict[col] = label\n",
    "            \n",
    "            # To fill\n",
    "            if self.fill:\n",
    "                self.fill_value[col] = X[col].mode()[0]\n",
    "                X[col] = X[col].fillna(self.fill_value[col])\n",
    "                \n",
    "        print('Label Encoding Done for {} columns'.format(len(self.columns)))\n",
    "        return self\n",
    "    def transform(self, X):\n",
    "        for col in self.columns:\n",
    "            if self.fill:\n",
    "                X[col] = X[col].fillna(self.fill_value[col])\n",
    "                \n",
    "            X.loc[:, col] = self.dict[col].transform(X[col])\n",
    "        print('Transformation Done')\n",
    "        return X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create a lemmatizer class(not mandatory but can help improve the model predictions)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Lemmatizer - if required\n",
    "class LemmaTokenizer(object):\n",
    "    def __init__(self):\n",
    "        self.wnl = WordNetLemmatizer()\n",
    "    def __call__(self, articles):\n",
    "        return [self.wnl.lemmatize(t) for t in word_tokenize(articles)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create a class that produces count and tf-idf encoded data. It has the capability to output sparse and dense data**\n",
    "It is recommended to use the sparse data output because space taken to store the data in memory can reduce by orders of magnitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to Create CountEncoded and tf-idf features\n",
    "def add_text_features(text_column_name, data_file, max_features = 2000, txn = 'tf-idf', min_df = 1, max_df = 1.0,\n",
    "                     ngram_range = (1, 1), lowercase = True, sparse = False, tokenizer = None):\n",
    "    if txn == 'count':\n",
    "        # Use Count Vectorizer\n",
    "        counts = CountVectorizer(max_features = max_features, min_df = min_df, \n",
    "        max_df = max_df, ngram_range = ngram_range, lowercase = lowercase, tokenizer=tokenizer).fit(data_file[text_column_name])\n",
    "    if txn == 'tf-idf':\n",
    "        counts = pipeline.make_pipeline(CountVectorizer(max_features = max_features, min_df = min_df, \n",
    "        max_df = max_df, ngram_range = ngram_range, lowercase = lowercase, tokenizer=tokenizer),\n",
    "                                        TfidfTransformer()).fit(data_file[text_column_name])\n",
    "    text_features = counts.transform(data_file[text_column_name])\n",
    "    \n",
    "    # Return for sparse output\n",
    "    if sparse: return text_features, None\n",
    "    \n",
    "    # Create Mapping\n",
    "    if txn == 'count':\n",
    "        mapping = {val: key for key, val in counts.vocabulary_.items()}\n",
    "    if txn == 'tf-idf':\n",
    "        mapping = {val: key for key, val in counts['countvectorizer'].vocabulary_.items()}\n",
    "    \n",
    "    # Create DataFrame\n",
    "    text_features_data = pd.DataFrame(text_features.toarray())\n",
    "    text_features_data = text_features_data.rename(mapping, axis = 1)\n",
    "    text_cols = text_features_data.columns.tolist()\n",
    "    \n",
    "    # Append to dataframe\n",
    "    data_copy = pd.concat([data_file.reset_index(drop = True), text_features_data.reset_index(drop = True)], axis = 1)\n",
    "    return data_copy, text_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label Encoding Done for 3 columns\n",
      "Transformation Done\n"
     ]
    }
   ],
   "source": [
    "# Label Encode Certain columns - for use later\n",
    "enc = categorical_encoder(columns = ['title_no','developer_no', 'publisher']).fit(data)\n",
    "data_copy = enc.transform(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Finally extract tf-idf sparse dataframe**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_copy, text_cols = add_text_features(text_column_name = 'user_review', \n",
    "                                     data_file = data_copy, max_features = 120000, min_df = 5, max_df = .5,\n",
    "                                    ngram_range = (1, 4), lowercase = True, sparse = True, tokenizer = LemmaTokenizer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data back to train and test\n",
    "X_train = data_copy[:train.shape[0], :]\n",
    "y_train = data['user_suggestion'].iloc[:train.shape[0]]\n",
    "\n",
    "X_test = data_copy[train.shape[0]:, :]\n",
    "y_test = data['user_suggestion'].iloc[train.shape[0]:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(17494, 120000) (8045, 120000)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape, X_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train model - Logistic Regression is a good option for Text classification problems\n",
    "model = linear_model.LogisticRegressionCV(penalty = 'l2', Cs = 10, max_iter = 5000).fit(X_train, y_train)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submission for Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "sub = pd.DataFrame()\n",
    "sub['review_id'] = test_id\n",
    "#sub['user_suggestion'] = (model.predict_proba(X_test)[:, 1]>.50).astype(int)\n",
    "sub['user_suggestion'] = model.predict(X_test).astype(int)\n",
    "sub['user_suggestion'].value_counts()\n",
    "sub.to_csv('sub.csv', index = None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***The submission yielded a Binary F1 score of 0.8701 on the Public Leaderboard***"
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}