010.Preprocessing_Feature_Engineering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing\n",
    "I'll take a look at text data and turn it into quantifiable measures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From randomly sampled tweets, I decided to do at least the following: \n",
    "\n",
    "1. find any links and remove them (e.g. bit.ly/g03MZB)\n",
    "2. `@mention`, `{link}`\n",
    "Create a feature that shows how many of these exists, but remove them from tokenization.\n",
    "3. `[\\w+]` seems to be emoji or pics/videos. keep them as is (with brackets) \n",
    "3. word after # should be treated as a separate word than the same word without #, also count how many tags\n",
    "4. `?&quot;`, `$amp;`, `�` should be removed.\n",
    "5. ! and ? might be important to keep. count how many. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Data\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = pd.read_csv('DATA/X_train.csv', index_col=0)\n",
    "X_val = pd.read_csv('DATA/X_val.csv', index_col=0)\n",
    "X_test = pd.read_csv('DATA/X_test.csv', index_col=0)\n",
    "y_train = pd.read_csv('DATA/y_train.csv', index_col = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Capitalized\n",
    "Sometimes capitalized letters indicate stronger sentiment. Let's see proportionally what percent of characters are capitalized, before we make everything lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_upper(str_):\n",
    "    return sum([x.isupper() for x in str_])/len(str_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperlinks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find links and turn them into {link}\n",
    "def replace_links(str_):\n",
    "    p = '((http\\w*:\\/\\/)?(www\\.\\w+)?(\\w+\\.(com|co|ly|ch|org|net)+)(\\/\\w+)?)'\n",
    "    return re.sub(p, '{link}', str_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count \n",
    "Count how many mentions, tags, links, '!', '?', '.' happened"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count how many times specific expression occurs.\n",
    "def count_exp(str_, exp):\n",
    "    p = re.compile(exp)\n",
    "    return len(p.findall(str_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove HTML symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove html symbol\n",
    "def remove_html(str_):\n",
    "    return re.sub(\"[^A-Za-z0-9 ]\\w+\", ' ', str_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove Mentions and Links"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove mentions\n",
    "def remove_mentions(str_):\n",
    "    return re.sub(\"(@\\w*)\", ' ', str_)\n",
    "\n",
    "# remove links\n",
    "def remove_links(str_):\n",
    "    return re.sub(\"(\\{\\w*\\})\", ' ', str_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove unnecessary punctuations\n",
    "(remove ones except #,[])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove unnecessary punctuations \n",
    "import string\n",
    "punctuations = string.punctuation\n",
    "punctuations = punctuations + '�' + string.digits\n",
    "\n",
    "def remove_punctuations(str_, punctuations):\n",
    "    table_ = str.maketrans('', '', punctuations)\n",
    "    return str_.translate(table_)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change brand words\n",
    "We don't want overall distribution of customer satisfaction of each company to affect our analysis so I'll remove some of the specific words for popular brands. Let's change these words to 'gn' (remove when tokenized, but CFG. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_brandwords(str_):\n",
    "    p = '''#?(iphone|ipad|sxsw|hcsm|google|apple|cisco|austin|\n",
    "    atari|intel|mac|pc|blackberry|android|linux|ubuntu)[a-z0-9]*'''\n",
    "    return re.sub(p, ' gn ', str_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lemmatization\n",
    "Finally, lemmatizing the vocabularies. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.stem import WordNetLemmatizer\n",
    "def lemmatize(str_):\n",
    "    wnl = WordNetLemmatizer()\n",
    "    return wnl.lemmatize(str_) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stopwords\n",
    "Define stopwords. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stopwords\n",
    "sw = stopwords.words('english')\n",
    "sw += ['gn']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting them together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def prepro_text(df0, punctuations, stopwords):\n",
    "    df = df0.copy()\n",
    "    df['upper_count'] = df.tweet.apply(lambda x: count_upper(x))\n",
    "    # only keep ascii characters\n",
    "    df['tweet'] = df.tweet.apply(lambda x: x.encode(\"ascii\", \"ignore\").decode())\n",
    "    df['tweet'] = df.tweet.apply(lambda x: x.lower())\n",
    "    df['tweet'] = df.tweet.apply(replace_links)\n",
    "    df['tweet'] = df.tweet.apply(lambda x: remove_html(x))    \n",
    "    df['tweet'] = df.tweet.apply(lambda x: change_brandwords(x))    \n",
    "    # uncomment below if specialcounts are needed\n",
    "    #df['mention_count'] = df.tweet.apply(lambda x: count_exp(x, '@\\w+'))\n",
    "    #df['link_count'] = df.tweet.apply(lambda x: count_exp(x, '{link}')) \n",
    "    #df['tag_count'] = df.tweet.apply(lambda x: count_exp(x, '#\\w+'))\n",
    "    #df['exclam_count'] = df.tweet.apply(lambda x: count_exp(x, '!'))\n",
    "    #df['quest_count'] = df.tweet.apply(lambda x: count_exp(x, '\\?'))\n",
    "    #df['period_count'] = df.tweet.apply(lambda x: count_exp(x, '\\.'))\n",
    "    #df['tag_count'] = df.tweet.apply(lambda x: count_exp(x, '#\\w+'))\n",
    "    df['tweet'] = df.tweet.apply(lambda x: remove_mentions(x))\n",
    "    df['tweet'] = df.tweet.apply(lambda x: remove_links(x))\n",
    "    df['tweet'] = df.tweet.apply(lambda x: remove_punctuations(x, punctuations))    \n",
    "    df['tweet'] = df.tweet.apply(lambda x: ' '.join([lemmatize(w) for w in x.split() if (len(w) > 1) & (w not in stopwords)]))\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_pp = prepro_text(X_train, punctuations, sw)\n",
    "X_val_pp = prepro_text(X_val, punctuations, sw)\n",
    "X_test_pp = prepro_text(X_test, punctuations, sw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection\n",
    "I'll now purge some of the words that only happen once by combining them with the other most similar words using Spacy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_words = list(chain.from_iterable([x.split() for x in X_train_pp['tweet']]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5386"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_vocab = len(set(all_words))\n",
    "n_vocab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "import spacy\n",
    "from collections import Counter\n",
    "\n",
    "\n",
    "# loading the corpus \n",
    "import en_core_web_lg\n",
    "nlp = en_core_web_lg.load()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for words that occur only once, find the next similar existing word\n",
    "def consolidate_words(textlist, thresh = .8):\n",
    "    '''\n",
    "    Takes a list of texts to run iteration\n",
    "    Change word that occurs only once to similar word in the text\n",
    "    Return consolidated list \n",
    "    '''\n",
    "    list_of_text = textlist.copy()\n",
    "    wordcounts = Counter(' '.join(list_of_text).split())    \n",
    "    words_once = [k for k, v in wordcounts.items() if v <= 2]\n",
    "    other_words = [k for k, v in wordcounts.items() if v > 2]\n",
    "    \n",
    "    tokens = nlp(' '.join(other_words))\n",
    "    replacement_dict = {}\n",
    "    for word in words_once:\n",
    "\n",
    "        word_token = nlp(word)\n",
    "        max_similarity = thresh\n",
    "\n",
    "        for tk in tokens:\n",
    "            # find the maximum similarity above threshold\n",
    "            sim_score = word_token.text, tk.text, word_token.similarity(tk)\n",
    "            if 1 > sim_score[2] > max_similarity:\n",
    "                replacement_dict[word] = sim_score[1]\n",
    "                max_similarity = sim_score[2]\n",
    "        try:\n",
    "            print(word, 'to', replacement_dict[word])\n",
    "        except KeyError:\n",
    "            continue\n",
    "    \n",
    "    return replacement_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "replacement_dict = consolidate_words(all_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_texts(input_texts, replacement_dict = replacement_dict):\n",
    "    list_texts = input_texts.copy()\n",
    "    new_texts = []\n",
    "    for text in list_texts:\n",
    "        tex = text.split()\n",
    "        for i, t in enumerate(tex):\n",
    "            if t in replacement_dict:\n",
    "                tex[i] = replacement_dict[t]\n",
    "        new_texts.append(' '.join([x for x in tex if len(x) > 1]))\n",
    "    return new_texts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_pp['tweet'] = replace_texts(X_train_pp['tweet'])\n",
    "X_val_pp['tweet'] = replace_texts(X_val_pp['tweet'])\n",
    "X_test_pp['tweet'] = replace_texts(X_test_pp['tweet'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5215"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_words = list(chain.from_iterable([x.split() for x in X_train_pp['tweet']]))\n",
    "n_vocab = len(set(all_words))\n",
    "n_vocab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export Pickles\n",
    "Export preprocessed data out as pickles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import os\n",
    "#os.mkdir('PKL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_pp.to_pickle('PKL/X_train_fin.pkl')\n",
    "X_val_pp.to_pickle('PKL/X_val_fin.pkl')\n",
    "X_test_pp.to_pickle('PKL/X_test_fin.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EDA\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combining with target \n",
    "train_pp = X_train_pp.join(y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tokenize \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now tokenize and remove stopwords\n",
    "def tokenize(str_, stopwords):\n",
    "    return [x for x in word_tokenize(str_) if x not in stopwords]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_pp['tweet'] = train_pp.tweet.apply(lambda x: tokenize(x, sw))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative vs. Positve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "No emotion toward brand or product    2635\n",
       "Positive emotion                      1547\n",
       "Negative emotion                       306\n",
       "Name: sentiment, dtype: int64"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_pp.sentiment.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "neg_texts = train_pp[train_pp.sentiment == 'Negative emotion']['tweet']\n",
    "pos_texts = train_pp[train_pp.sentiment == 'Positive emotion']['tweet']\n",
    "neu_texts = train_pp[train_pp.sentiment == 'No emotion toward brand or product']['tweet']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "neg_text = np.sum(neg_texts)\n",
    "pos_text = np.sum(pos_texts)\n",
    "neu_text = np.sum(neu_texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('fivethirtyeight')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "top30_neg = dict(Counter(neg_text).most_common(30))\n",
    "top30_pos = dict(Counter(pos_text).most_common(30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(top30_neg.keys(), top30_neg.values())\n",
    "plt.xticks(rotation = 90)\n",
    "plt.title('negative emotion top 30 frequent words')\n",
    "plt.show()\n",
    "\n",
    "plt.bar(top30_pos.keys(), top30_pos.values())\n",
    "plt.xticks(rotation = 90)\n",
    "plt.title('positive emotion top 30 frequent words')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Average Word Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import word2vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# building GloVe dictionary\n",
    "glove_path = '/Users/stereopickles/Documents/GloVe/glove.twitter.27B/glove.twitter.27B.50d.txt'\n",
    "glove_path_pc = 'D:\\Projects\\GloVe_Twitter\\glove.twitter.27B.50d.txt'\n",
    "glove_dict = {}\n",
    "with open(glove_path_pc, 'r', encoding = 'utf-8') as f:\n",
    "    for line in f:\n",
    "        vals = line.split(' ')\n",
    "        glove_dict[vals[0]] = np.asarray(vals[1:], dtype = 'float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train_tweet = X_train_fin.tweet_df.apply(lambda x: tokenize(x, sw))\n",
    "X_val_tweet = X_val_fin.tweet_df.apply(lambda x: tokenize(x, sw))\n",
    "X_test_tweet = X_test_fin.tweet_df.apply(lambda x: tokenize(x, sw))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate the average word vector\n",
    "def get_mean_vector(list_):\n",
    "    veclist = [glove_dict[x] for x in list_ if x in glove_dict]\n",
    "    if veclist: return np.mean(veclist)\n",
    "    else: return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_mean_vec = X_train_tweet.apply(lambda x: get_mean_vector(x))\n",
    "X_val_mean_vec = X_val_tweet.apply(lambda x: get_mean_vector(x))\n",
    "X_test_mean_vec = X_test_tweet.apply(lambda x: get_mean_vector(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_fin['mean_vec'] = X_train_mean_vec\n",
    "X_val_fin['mean_vec'] = X_val_mean_vec\n",
    "X_test_fin['mean_vec'] = X_test_mean_vec"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}