Model-RandomForest.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check if IS_MASTER exists, this variable will only exist if it's being called by MASTER notebook.\n",
    "# if it does not exist, set it to False\n",
    "try: IS_MASTER\n",
    "except: IS_MASTER = False\n",
    "# The code below will only run if it's NOT being called from MASTER notebook\n",
    "if not IS_MASTER:\n",
    "    DATA_DIR = './data/temp/'\n",
    "    EXP_DIR = './exp/temp/'\n",
    "    PROCESSED_FILE = f'{DATA_DIR}processed.pkl'\n",
    "    MODEL_FILE = f'{EXP_DIR}model.pkl'\n",
    "    PREDICTION_FILE = f'{EXP_DIR}ypred.pkl'\n",
    "    OTHER_MODEL_PARAMETERS = ... # like N_ESTIMATOR, GAMMA, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:File `'plot_learning_curve.py'` not found.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import Series, DataFrame\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn\n",
    "%matplotlib inline\n",
    "%run plot_learning_curve\n",
    "import pickle\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>id</th>\n",
       "      <th>text</th>\n",
       "      <th>full_text</th>\n",
       "      <th>text2Proc</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14286</th>\n",
       "      <td>1.194698e+18</td>\n",
       "      <td>Cómo consumir un buen vermut (Olvídate del hie...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Cómo consumir un buen vermut (Olvídate del hie...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8480</th>\n",
       "      <td>1.194663e+18</td>\n",
       "      <td>Lo cierto que si Albert Rivera era la veleta n...</td>\n",
       "      <td>Lo cierto que si Albert Rivera era la veleta n...</td>\n",
       "      <td>Lo cierto que si Albert Rivera era la veleta n...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4515</th>\n",
       "      <td>1.194641e+18</td>\n",
       "      <td>Cuando mi madre me pone lentejas</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Cuando mi madre me pone lentejas</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>233</th>\n",
       "      <td>1.194612e+18</td>\n",
       "      <td>@Soumastre Jajajjaa palabras de un chico reali...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>@Soumastre Jajajjaa palabras de un chico reali...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10952</th>\n",
       "      <td>1.194677e+18</td>\n",
       "      <td>Mango se viste de etiqueta para dar la bienven...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Mango se viste de etiqueta para dar la bienven...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 id                                               text  \\\n",
       "14286  1.194698e+18  Cómo consumir un buen vermut (Olvídate del hie...   \n",
       "8480   1.194663e+18  Lo cierto que si Albert Rivera era la veleta n...   \n",
       "4515   1.194641e+18                   Cuando mi madre me pone lentejas   \n",
       "233    1.194612e+18  @Soumastre Jajajjaa palabras de un chico reali...   \n",
       "10952  1.194677e+18  Mango se viste de etiqueta para dar la bienven...   \n",
       "\n",
       "                                               full_text  \\\n",
       "14286                                                NaN   \n",
       "8480   Lo cierto que si Albert Rivera era la veleta n...   \n",
       "4515                                                 NaN   \n",
       "233                                                  NaN   \n",
       "10952                                                NaN   \n",
       "\n",
       "                                               text2Proc  target  \n",
       "14286  Cómo consumir un buen vermut (Olvídate del hie...       0  \n",
       "8480   Lo cierto que si Albert Rivera era la veleta n...       0  \n",
       "4515                    Cuando mi madre me pone lentejas       0  \n",
       "233    @Soumastre Jajajjaa palabras de un chico reali...       0  \n",
       "10952  Mango se viste de etiqueta para dar la bienven...       0  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_pickle(PROCESSED_FILE)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 770 entries, 1865 to 499\n",
      "Data columns (total 3 columns):\n",
      "id           770 non-null float64\n",
      "text2Proc    770 non-null object\n",
      "target       770 non-null int64\n",
      "dtypes: float64(1), int64(1), object(1)\n",
      "memory usage: 24.1+ KB\n"
     ]
    }
   ],
   "source": [
    "df.info() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classifiers must work with numbers type so we have to transform object types into int64 types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classification\n",
    "==============\n",
    " Finally, we are going to create a model able to decide if a tweet talks about an incident It's important to have in mind that the entry of our classifier is a set of documents (or tweets), so to use text characteristics and the other columns from the DataFrame it's necesary to implement a series of tranformers to include the features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define X and Y\n",
    "X = df['text2Proc'].values\n",
    "y = df['target'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lexical Features\n",
    "================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample of statistics using nltk\n",
    "# Another option is defining a function and pass it as a parameter to FunctionTransformer\n",
    "\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from nltk.tokenize import sent_tokenize, word_tokenize\n",
    "\n",
    "class LexicalStats (BaseEstimator, TransformerMixin):\n",
    "    \"\"\"Extract lexical features from each document\"\"\"\n",
    "    \n",
    "    def number_sentences(self, doc):\n",
    "        sentences = sent_tokenize(doc, language='spanish')\n",
    "        return len(sentences)\n",
    "\n",
    "    def fit(self, x, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, docs):\n",
    "        return [{'length': len(doc),\n",
    "                 'num_sentences': self.number_sentences(doc)}\n",
    "                for doc in docs]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from nltk.stem import PorterStemmer\n",
    "from nltk import word_tokenize\n",
    "from nltk.tokenize import TweetTokenizer\n",
    "from nltk.corpus import stopwords\n",
    "import re\n",
    "import string\n",
    "\n",
    "def custom_tokenizer(words):\n",
    "    \"\"\"Preprocessing tokens as seen in the lexical notebook\"\"\"\n",
    "\n",
    "    urls = re.compile(r'.http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')\n",
    "    ht = re.compile(r'http.')\n",
    "    bar = re.compile(r'//*')\n",
    "    pr = [\"rt\",\"@\",\"http\",\"https\",\"'s\",'...', 'english', 'translation','):', '. .', '..']\n",
    "    #tknzr = TweetTokenizer(strip_handles=True, reduce_len=True)\n",
    "    tknzr = TweetTokenizer(strip_handles=False, reduce_len=True)\n",
    "    #tokens = word_tokenize(words.lower())\n",
    "    tokens = tknzr.tokenize(words.lower())\n",
    "    porter = PorterStemmer()\n",
    "    lemmas = [porter.stem(t) for t in tokens]\n",
    "    # Clean stop-words\n",
    "    stoplist = stopwords.words('spanish')\n",
    "    lemmas_clean = [w for w in lemmas if w not in stoplist]\n",
    "    # Clean punctuation\n",
    "    punctuation = set(string.punctuation)\n",
    "    lemmas_punct = [w for w in lemmas_clean if  w not in punctuation]\n",
    "    # Clean emojis,urls,bars,etc\n",
    "    lemmas_clean = [w for w in lemmas_punct if not w.startswith('@') if w not in pr \n",
    "            if not bar.search(w) if not ht.search(w)\n",
    "            if not w.isdigit()]\n",
    "    \n",
    "    return lemmas_clean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Extraction Pipelines\n",
    "===================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline, FeatureUnion\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer, TfidfTransformer\n",
    "\n",
    "\n",
    "ngrams_featurizer = Pipeline([\n",
    "  ('count_vectorizer',  CountVectorizer(ngram_range = (1, 3), encoding = 'utf-8', \n",
    "                                        tokenizer=custom_tokenizer)),\n",
    "  ('tfidf_transformer', TfidfTransformer())\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Union Pipeline\n",
    "======"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.model_selection import cross_val_score, KFold\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "from sklearn.decomposition import NMF, LatentDirichletAllocation\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report, accuracy_score, make_scorer\n",
    "\n",
    "def pipeline(clf):\n",
    "    return Pipeline([\n",
    "       ('features', FeatureUnion([\n",
    "                    ('lexical_stats', Pipeline([\n",
    "                                ('stats', LexicalStats()),\n",
    "                                ('vectors', DictVectorizer())\n",
    "                            ])),\n",
    "                    ('words', TfidfVectorizer(tokenizer=custom_tokenizer)),\n",
    "                    ('ngrams', ngrams_featurizer),\n",
    "                    # Topics of the Docs\n",
    "                    ('lda', Pipeline([ \n",
    "                                ('count', CountVectorizer(tokenizer=custom_tokenizer)),\n",
    "                                ('lda',  LatentDirichletAllocation(n_components=2, max_iter=5,\n",
    "                                                       learning_method='online', \n",
    "                                                       learning_offset=50.,\n",
    "                                                       random_state=0))\n",
    "                            ])),\n",
    "                ])),\n",
    "        # Machine Learning\n",
    "        ('clf', clf)  # classifier\n",
    "        #('clf', SVC(gamma= 3, kernel='linear', probability=True))\n",
    "\n",
    "    ])\n",
    "\n",
    "def classification_report_with_accuracy_score(y_true, y_pred):\n",
    "\n",
    "    print (classification_report(y_true, y_pred)) # print classification report\n",
    "    return accuracy_score(y_true, y_pred) # return accuracy score\n",
    "\n",
    "cv = KFold(n_splits=5, shuffle=True, random_state=33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train, Optimize and Evaluate models\n",
    "======"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "RandomForests\n",
    "------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "#Optimize RandomForests\n",
    "pipelineRF = pipeline(RandomForestClassifier(n_estimators=10,n_jobs=-1))\n",
    "\n",
    "parametersRF = {'clf__n_estimators': range (1,43)}\n",
    "\n",
    "gs_RF = GridSearchCV(pipelineRF, parametersRF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_RF= gs_RF.fit(X,y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score with RandomForests: 0.868831168831\n",
      "clf__n_estimators: 33\n"
     ]
    }
   ],
   "source": [
    "print(\"Best Score with RandomForests: %s\" % gs_RF.best_score_)\n",
    "for param_name in sorted(parametersRF.keys()):\n",
    "    print(\"%s: %r\" % (param_name, gs_RF.best_params_[param_name]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores in every iteration [ 0.83766234  0.87662338  0.85064935  0.84415584  0.94155844]\n",
      "Accuracy: 0.87 (+/- 0.08)\n"
     ]
    }
   ],
   "source": [
    "#Evaluate with K-Fold\n",
    "model_RF = pipeline(RandomForestClassifier(n_estimators=gs_RF.best_params_['clf__n_estimators'],n_jobs=-1))\n",
    "scores = cross_val_score(model_RF, X, y, cv=cv)\n",
    "print(\"Scores in every iteration\", scores)\n",
    "print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sklearn.pipeline.Pipeline"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(model_RF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Models/model_RF-d02.joblib']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from joblib import dump, load\n",
    "dump(model_RF, 'exp/models/model_RF.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores in every iteration [ 0.83766234  0.88961039  0.85064935  0.80519481  0.90909091]\n",
      "Accuracy: 0.86 (+/- 0.07)\n",
      "Scores in every iteration [ 0.92424242  0.95890411  0.89393939  0.95        0.87878788]\n",
      "Precision: 0.92 (+/- 0.06)\n",
      "Scores in every iteration [ 0.77777778  0.85365854  0.75        0.73809524  0.91935484]\n",
      "Recall: 0.81 (+/- 0.14)\n",
      "Scores in every iteration [ 0.76595745  0.87581699  0.82269504  0.8         0.92682927]\n",
      "F1: 0.84 (+/- 0.11)\n"
     ]
    }
   ],
   "source": [
    "clf = load('exp/models/model_RF.joblib') \n",
    "scores = cross_val_score(clf, X, y, cv=cv)\n",
    "print(\"Scores in every iteration\", scores)\n",
    "print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "scores = cross_val_score(clf, X, y, cv=cv, scoring='precision')\n",
    "print(\"Scores in every iteration\", scores)\n",
    "print(\"Precision: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "scores = cross_val_score(clf, X, y, cv=cv, scoring='recall')\n",
    "print(\"Scores in every iteration\", scores)\n",
    "print(\"Recall: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "scores = cross_val_score(clf, X, y, cv=cv, scoring='f1')\n",
    "print(\"Scores in every iteration\", scores)\n",
    "print(\"F1: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_random = df.sample(frac=1)\n",
    "r_features = df_random.text2Proc.values[:100]\n",
    "r_target = df_random.target.values[:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = clf.predict(r_features)\n",
    "expected = r_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0,\n",
       "       0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "       1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n",
       "       0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1,\n",
       "       0, 1, 0, 0, 1, 1, 0, 1])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0,\n",
       "       0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "       1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n",
       "       0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1,\n",
       "       0, 1, 0, 0, 1, 1, 0, 1])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.predict(['me apetece un par de birras'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "metrics.accuracy_score(expected, predicted) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from '/opt/conda/lib/python3.6/site-packages/matplotlib/pyplot.py'>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learning_curve(model_RF, \"Learning curve with K-Fold\", X, y, cv=cv) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.78      0.89      0.83        73\n",
      "           1       0.89      0.78      0.83        81\n",
      "\n",
      "    accuracy                           0.83       154\n",
      "   macro avg       0.84      0.83      0.83       154\n",
      "weighted avg       0.84      0.83      0.83       154\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.83      0.94      0.88        72\n",
      "           1       0.94      0.83      0.88        82\n",
      "\n",
      "    accuracy                           0.88       154\n",
      "   macro avg       0.89      0.89      0.88       154\n",
      "weighted avg       0.89      0.88      0.88       154\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.79      0.94      0.86        78\n",
      "           1       0.92      0.75      0.83        76\n",
      "\n",
      "    accuracy                           0.84       154\n",
      "   macro avg       0.86      0.84      0.84       154\n",
      "weighted avg       0.86      0.84      0.84       154\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.76      0.96      0.85        70\n",
      "           1       0.95      0.75      0.84        84\n",
      "\n",
      "    accuracy                           0.84       154\n",
      "   macro avg       0.86      0.85      0.84       154\n",
      "weighted avg       0.87      0.84      0.84       154\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      0.90      0.93        92\n",
      "           1       0.87      0.94      0.90        62\n",
      "\n",
      "    accuracy                           0.92       154\n",
      "   macro avg       0.91      0.92      0.91       154\n",
      "weighted avg       0.92      0.92      0.92       154\n",
      "\n",
      "[ 0.83116883  0.88311688  0.84415584  0.84415584  0.91558442]\n"
     ]
    }
   ],
   "source": [
    "# Nested CV with parameter optimization\n",
    "nested_score = cross_val_score(model_RF, X, y, cv=cv, \\\n",
    "               scoring=make_scorer(classification_report_with_accuracy_score))\n",
    "print (nested_score) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "         steps=[('features',\n",
       "                 FeatureUnion(n_jobs=None,\n",
       "                              transformer_list=[('lexical_stats',\n",
       "                                                 Pipeline(memory=None,\n",
       "                                                          steps=[('stats',\n",
       "                                                                  LexicalStats()),\n",
       "                                                                 ('vectors',\n",
       "                                                                  DictVectorizer(dtype=<class 'numpy.float64'>,\n",
       "                                                                                 separator='=',\n",
       "                                                                                 sort=True,\n",
       "                                                                                 sparse=True))],\n",
       "                                                          verbose=False)),\n",
       "                                                ('words',\n",
       "                                                 TfidfVectorizer(analyzer='word',\n",
       "                                                                 binary=False,\n",
       "                                                                 decode_error='strict',\n",
       "                                                                 dtype=<clas...\n",
       "                 RandomForestClassifier(bootstrap=True, ccp_alpha=0.0,\n",
       "                                        class_weight=None, criterion='gini',\n",
       "                                        max_depth=None, max_features='auto',\n",
       "                                        max_leaf_nodes=None, max_samples=None,\n",
       "                                        min_impurity_decrease=0.0,\n",
       "                                        min_impurity_split=None,\n",
       "                                        min_samples_leaf=1, min_samples_split=2,\n",
       "                                        min_weight_fraction_leaf=0.0,\n",
       "                                        n_estimators=33, n_jobs=-1,\n",
       "                                        oob_score=False, random_state=None,\n",
       "                                        verbose=0, warm_start=False))],\n",
       "         verbose=False)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Train classifier\n",
    "model_RF.fit(X,y)"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}