emotion_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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>Field1</th>\n",
       "      <th>SIT</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>joy</td>\n",
       "      <td>During the period of falling in love, each tim...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>fear</td>\n",
       "      <td>When I was involved in a traffic accident.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>anger</td>\n",
       "      <td>When I was driving home after  several days of...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>sadness</td>\n",
       "      <td>When I lost the person who meant the most to me.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>disgust</td>\n",
       "      <td>The time I knocked a deer down - the sight of ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Field1                                                SIT\n",
       "0      joy  During the period of falling in love, each tim...\n",
       "1     fear         When I was involved in a traffic accident.\n",
       "2    anger  When I was driving home after  several days of...\n",
       "3  sadness  When I lost the person who meant the most to me. \n",
       "4  disgust  The time I knocked a deer down - the sight of ..."
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "path_emotion_file = \"isear.csv\"\n",
    "\n",
    "# read csv\n",
    "df_file = pd.read_csv(path_emotion_file, error_bad_lines=False,\n",
    "                      warn_bad_lines=False, sep='|', encoding='latin1')\n",
    "\n",
    "df = df_file[['Field1', 'SIT']]\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7503, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['joy', 'fear', 'anger', 'sadness', 'disgust', 'shame', 'guilt'],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.Field1.unique() # target values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field1\n",
       "anger      1070\n",
       "disgust    1058\n",
       "fear       1079\n",
       "guilt      1070\n",
       "joy        1065\n",
       "sadness    1080\n",
       "shame      1081\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('Field1').size() # target value sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[df['Field1'].str.contains('anger|disgust|fear|joy|sadness|guilt|shame')]\n",
    "df = df[~df['SIT'].str.contains('\\[')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field1\n",
       "anger      1045\n",
       "disgust    1029\n",
       "fear       1064\n",
       "guilt      1030\n",
       "joy        1048\n",
       "sadness    1051\n",
       "shame      1038\n",
       "dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('Field1').size() # target value sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "raw_data = np.array(df['SIT'].values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7305"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(raw_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from nltk.stem.lancaster import LancasterStemmer\n",
    "from nltk.corpus import stopwords\n",
    "\n",
    "def preprocess_text(text, stemming=False, stop_word=False):\n",
    "    text = re.sub('((www\\.[^\\s]+)|(https?://[^\\s]+))','URL', text)\n",
    "    text = re.sub('@[^\\s]+','USER', text)\n",
    "    text = text.lower().replace(\"ё\", \"е\")\n",
    "    text = re.sub('[^a-zA-Zа-яА-Я1-9]+', ' ', text)\n",
    "    text = re.sub(' +',' ', text)\n",
    "    text = text.strip()\n",
    "    \n",
    "    # This part for stemming.\n",
    "    if stemming:\n",
    "        stemmer = LancasterStemmer()\n",
    "        text = text.split()\n",
    "        text = \" \".join([stemmer.stem(w) for w in text])\n",
    "    \n",
    "    # This part for removing stopwords.\n",
    "    if stop_word:\n",
    "        text = text.split()\n",
    "        stop_words = set(stopwords.words('english'))\n",
    "        text = \" \".join([w for w in text if not w in stop_words])\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "\n",
    "def printresult(clf):\n",
    "    for mean, std, params in zip(clf.cv_results_['mean_test_score'], \n",
    "                             clf.cv_results_['std_test_score'], \n",
    "                             clf.cv_results_['params']):\n",
    "        print(\"%0.3f (+/-%0.03f) for %r\" % (mean, std * 2, params))\n",
    "        print()\n",
    "    \n",
    "    print(\"Detailed classification report:\")\n",
    "    print()\n",
    "    print(\"The model is trained on the full development set.\")\n",
    "    print(\"The scores are computed on the full evaluation set.\")\n",
    "    print()\n",
    "    print(classification_report(y_test, clf.predict(x_test), digits=2))\n",
    "    print()\n",
    "    print(\"Best parameters:\")\n",
    "    print(clf.best_params_)\n",
    "    \n",
    "def crossValidation(algorithm, parameters, folds, X, y):\n",
    "    gs = GridSearchCV(algorithm, parameters, cv=folds, scoring='f1_macro')\n",
    "    gs = gs.fit(X, y)\n",
    "    print(\"Best Score %.3f\" % (gs.best_score_))\n",
    "    for param_name in sorted(parameters.keys()):\n",
    "        print(\"%s: %r\" % (param_name, gs.best_params_[param_name]))\n",
    "    result = pd.DataFrame(gs.cv_results_)\n",
    "    return result\n",
    "\n",
    "text_clf = Pipeline([('vect', CountVectorizer()),\n",
    "                     ('tfidf', TfidfTransformer()),\n",
    "                     ('clf', MultinomialNB())])\n",
    "\n",
    "tuned_parameters = {\n",
    "    'vect__ngram_range': [(1, 1), (1, 2), (2, 2)],\n",
    "    'tfidf__use_idf': (True, False),\n",
    "    'tfidf__norm': ('l1', 'l2'),\n",
    "    'clf__alpha': [1, 1e-1, 1e-2]\n",
    "}\n",
    "\n",
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TEST 1: No Stemming, No Stopwords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score 0.572\n",
      "clf__alpha: 0.1\n",
      "tfidf__norm: 'l2'\n",
      "tfidf__use_idf: False\n",
      "vect__ngram_range: (1, 2)\n"
     ]
    },
    {
     "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>rank_test_score</th>\n",
       "      <th>param_tfidf__use_idf</th>\n",
       "      <th>param_clf__alpha</th>\n",
       "      <th>param_vect__ngram_range</th>\n",
       "      <th>mean_test_score</th>\n",
       "      <th>mean_train_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.571831</td>\n",
       "      <td>0.978656</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>2</td>\n",
       "      <td>True</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.570454</td>\n",
       "      <td>0.991232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>3</td>\n",
       "      <td>True</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.565405</td>\n",
       "      <td>0.951801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>4</td>\n",
       "      <td>False</td>\n",
       "      <td>0.01</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.563874</td>\n",
       "      <td>0.985326</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>5</td>\n",
       "      <td>False</td>\n",
       "      <td>0.01</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.562267</td>\n",
       "      <td>0.992067</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    rank_test_score param_tfidf__use_idf param_clf__alpha  \\\n",
       "22                1                False              0.1   \n",
       "19                2                 True              0.1   \n",
       "7                 3                 True                1   \n",
       "28                4                False             0.01   \n",
       "34                5                False             0.01   \n",
       "\n",
       "   param_vect__ngram_range  mean_test_score  mean_train_score  \n",
       "22                  (1, 2)         0.571831          0.978656  \n",
       "19                  (1, 2)         0.570454          0.991232  \n",
       "7                   (1, 2)         0.565405          0.951801  \n",
       "28                  (1, 2)         0.563874          0.985326  \n",
       "34                  (1, 2)         0.562267          0.992067  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [preprocess_text(t) for t in raw_data] # Without stemming.\n",
    "x_train, x_test, y_train, y_test = train_test_split(data, df.Field1.values, test_size=0.33, random_state=42)\n",
    "\n",
    "result00 = crossValidation(text_clf, tuned_parameters, 10, x_train, y_train)\n",
    "\n",
    "result00 = result00[[\"rank_test_score\", \"param_tfidf__use_idf\",\"param_clf__alpha\",\"param_vect__ngram_range\", \n",
    "                \"mean_test_score\", \"mean_train_score\"]]\n",
    "result00 = result00.sort_values(by=\"rank_test_score\")\n",
    "\n",
    "result00.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  TEST 2: With Stemming, no Stopwords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score 0.582\n",
      "clf__alpha: 0.1\n",
      "tfidf__norm: 'l2'\n",
      "tfidf__use_idf: False\n",
      "vect__ngram_range: (1, 2)\n"
     ]
    },
    {
     "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>rank_test_score</th>\n",
       "      <th>param_tfidf__use_idf</th>\n",
       "      <th>param_clf__alpha</th>\n",
       "      <th>param_vect__ngram_range</th>\n",
       "      <th>mean_test_score</th>\n",
       "      <th>mean_train_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.581987</td>\n",
       "      <td>0.974217</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>2</td>\n",
       "      <td>True</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.574952</td>\n",
       "      <td>0.988726</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>3</td>\n",
       "      <td>True</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.574103</td>\n",
       "      <td>0.940241</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>4</td>\n",
       "      <td>False</td>\n",
       "      <td>0.01</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.570544</td>\n",
       "      <td>0.982176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>5</td>\n",
       "      <td>False</td>\n",
       "      <td>0.01</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.565046</td>\n",
       "      <td>0.990607</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    rank_test_score param_tfidf__use_idf param_clf__alpha  \\\n",
       "22                1                False              0.1   \n",
       "19                2                 True              0.1   \n",
       "7                 3                 True                1   \n",
       "28                4                False             0.01   \n",
       "34                5                False             0.01   \n",
       "\n",
       "   param_vect__ngram_range  mean_test_score  mean_train_score  \n",
       "22                  (1, 2)         0.581987          0.974217  \n",
       "19                  (1, 2)         0.574952          0.988726  \n",
       "7                   (1, 2)         0.574103          0.940241  \n",
       "28                  (1, 2)         0.570544          0.982176  \n",
       "34                  (1, 2)         0.565046          0.990607  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [preprocess_text(t, stemming=True) for t in raw_data] # With stemming.\n",
    "x_train, x_test, y_train, y_test = train_test_split(data, df.Field1.values, test_size=0.33, random_state=42)\n",
    "\n",
    "result01 = crossValidation(text_clf, tuned_parameters, 10, x_train, y_train)\n",
    "\n",
    "result01 = result01[[\"rank_test_score\", \"param_tfidf__use_idf\",\"param_clf__alpha\",\"param_vect__ngram_range\", \n",
    "                \"mean_test_score\", \"mean_train_score\"]]\n",
    "result01 = result01.sort_values(by=\"rank_test_score\")\n",
    "\n",
    "result01.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TEST 3: With Stopwords, no Stemming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score 0.561\n",
      "clf__alpha: 1\n",
      "tfidf__norm: 'l2'\n",
      "tfidf__use_idf: True\n",
      "vect__ngram_range: (1, 2)\n"
     ]
    },
    {
     "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>rank_test_score</th>\n",
       "      <th>param_tfidf__use_idf</th>\n",
       "      <th>param_clf__alpha</th>\n",
       "      <th>param_vect__ngram_range</th>\n",
       "      <th>mean_test_score</th>\n",
       "      <th>mean_train_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.561337</td>\n",
       "      <td>0.973153</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>2</td>\n",
       "      <td>False</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.555281</td>\n",
       "      <td>0.987875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>3</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.554263</td>\n",
       "      <td>0.918542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>4</td>\n",
       "      <td>False</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.547978</td>\n",
       "      <td>0.959239</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>5</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 1)</td>\n",
       "      <td>0.546783</td>\n",
       "      <td>0.786890</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    rank_test_score param_tfidf__use_idf param_clf__alpha  \\\n",
       "7                 1                 True                1   \n",
       "22                2                False              0.1   \n",
       "10                3                False                1   \n",
       "16                4                False              0.1   \n",
       "9                 5                False                1   \n",
       "\n",
       "   param_vect__ngram_range  mean_test_score  mean_train_score  \n",
       "7                   (1, 2)         0.561337          0.973153  \n",
       "22                  (1, 2)         0.555281          0.987875  \n",
       "10                  (1, 2)         0.554263          0.918542  \n",
       "16                  (1, 2)         0.547978          0.959239  \n",
       "9                   (1, 1)         0.546783          0.786890  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [preprocess_text(t, stop_word=True) for t in raw_data] # With stemming.\n",
    "x_train, x_test, y_train, y_test = train_test_split(data, df.Field1.values, test_size=0.33, random_state=42)\n",
    "\n",
    "result10 = crossValidation(text_clf, tuned_parameters, 10, x_train, y_train)\n",
    "\n",
    "result10 = result10[[\"rank_test_score\", \"param_tfidf__use_idf\",\"param_clf__alpha\",\"param_vect__ngram_range\", \n",
    "                \"mean_test_score\", \"mean_train_score\"]]\n",
    "result10 = result10.sort_values(by=\"rank_test_score\")\n",
    "\n",
    "result10.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TEST 4: With Stemming and Stopwords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score 0.565\n",
      "clf__alpha: 1\n",
      "tfidf__norm: 'l2'\n",
      "tfidf__use_idf: False\n",
      "vect__ngram_range: (1, 2)\n"
     ]
    },
    {
     "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>rank_test_score</th>\n",
       "      <th>param_tfidf__use_idf</th>\n",
       "      <th>param_clf__alpha</th>\n",
       "      <th>param_vect__ngram_range</th>\n",
       "      <th>mean_test_score</th>\n",
       "      <th>mean_train_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.565379</td>\n",
       "      <td>0.899977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>2</td>\n",
       "      <td>True</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.565161</td>\n",
       "      <td>0.967421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>3</td>\n",
       "      <td>False</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.564600</td>\n",
       "      <td>0.986142</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>4</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>(1, 1)</td>\n",
       "      <td>0.557815</td>\n",
       "      <td>0.745058</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>5</td>\n",
       "      <td>False</td>\n",
       "      <td>0.1</td>\n",
       "      <td>(1, 2)</td>\n",
       "      <td>0.555431</td>\n",
       "      <td>0.944892</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    rank_test_score param_tfidf__use_idf param_clf__alpha  \\\n",
       "10                1                False                1   \n",
       "7                 2                 True                1   \n",
       "22                3                False              0.1   \n",
       "9                 4                False                1   \n",
       "16                5                False              0.1   \n",
       "\n",
       "   param_vect__ngram_range  mean_test_score  mean_train_score  \n",
       "10                  (1, 2)         0.565379          0.899977  \n",
       "7                   (1, 2)         0.565161          0.967421  \n",
       "22                  (1, 2)         0.564600          0.986142  \n",
       "9                   (1, 1)         0.557815          0.745058  \n",
       "16                  (1, 2)         0.555431          0.944892  "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [preprocess_text(t, True, True) for t in raw_data] # With stemming.\n",
    "x_train, x_test, y_train, y_test = train_test_split(data, df.Field1.values, test_size=0.33, random_state=42)\n",
    "\n",
    "result11 = crossValidation(text_clf, tuned_parameters, 10, x_train, y_train)\n",
    "\n",
    "result11 = result11[[\"rank_test_score\", \"param_tfidf__use_idf\",\"param_clf__alpha\",\"param_vect__ngram_range\", \n",
    "                \"mean_test_score\", \"mean_train_score\"]]\n",
    "result11 = result11.sort_values(by=\"rank_test_score\")\n",
    "\n",
    "result11.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get our results. And test with (1,2) ngram range, alpha 0.1, with stopwords and stemming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score of test is:\n",
      "0.560\n"
     ]
    }
   ],
   "source": [
    "test = Pipeline([('vect', CountVectorizer(ngram_range=(1,2))),\n",
    "                     ('tfidf', TfidfTransformer(use_idf=False)),\n",
    "                     ('clf', MultinomialNB(alpha=0.1))])\n",
    "\n",
    "data = [preprocess_text(t, stemming=True, stop_word=True) for t in raw_data] # With stemming.\n",
    "x_train, x_test, y_train, y_test = train_test_split(data, df.Field1.values, test_size=0.33, random_state=5)\n",
    "\n",
    "test.fit(x_train, y_train)\n",
    "\n",
    "predicted = test.predict(x_test)\n",
    "print(\"Score of test is:\")\n",
    "print(\"%.3f\"%(np.mean(predicted == y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Most effective 10 words for each class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anger: person told tim moth becaus thi wer hav angry friend\n",
      "disgust: som person felt disgust someon man felt peopl friend saw disgust\n",
      "fear: tim bef would wer afraid hom alon car fear night\n",
      "joy: happy tim year univers exam first aft got pass friend\n",
      "sadness: grandmoth year dea rel aft fath felt sad died friend\n",
      "shame: feel som thi day felt asham tim hav felt asham friend\n"
     ]
    }
   ],
   "source": [
    "def show_top10(classifier, vectorizer, categories):\n",
    "    feature_names = np.asarray(vectorizer.get_feature_names())\n",
    "    for i, category in enumerate(categories):\n",
    "        top10 = np.argsort(classifier.coef_[i])[-10:]\n",
    "        print(\"%s: %s\" % (category, \" \".join(feature_names[top10])))\n",
    "\n",
    "\n",
    "show_top10(test.steps[2][1], test.steps[0][1], test.classes_)"
   ]
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}