notebook/ML Pipeline Preparation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML Pipeline Preparation\n",
    "Follow the instructions below to help you create your ML pipeline.\n",
    "### 1. Import libraries and load data from database.\n",
    "- Import Python libraries\n",
    "- Load dataset from database with [`read_sql_table`](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_sql_table.html)\n",
    "- Define feature and target variables X and Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sqlalchemy import create_engine\n",
    "import re\n",
    "import nltk\n",
    "from sklearn.pipeline import Pipeline, FeatureUnion\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem.wordnet import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "from sklearn.multioutput import MultiOutputClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.metrics import classification_report\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to /home/sajith/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /home/sajith/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n",
      "[nltk_data] Downloading package punkt to /home/sajith/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')\n",
    "nltk.download('punkt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data from database\n",
    "engine = create_engine('sqlite:///InsertDatabaseName.db')\n",
    "df = pd.read_sql(\"select * from InsertTableName\", engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "news      13054\n",
       "direct    10766\n",
       "social     2396\n",
       "Name: genre, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['genre'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id                         True\n",
       "message                   False\n",
       "original                   True\n",
       "genre                     False\n",
       "related                    True\n",
       "request                   False\n",
       "offer                     False\n",
       "aid_related               False\n",
       "medical_help              False\n",
       "medical_products          False\n",
       "search_and_rescue         False\n",
       "security                  False\n",
       "military                  False\n",
       "child_alone               False\n",
       "water                     False\n",
       "food                      False\n",
       "shelter                   False\n",
       "clothing                  False\n",
       "money                     False\n",
       "missing_people            False\n",
       "refugees                  False\n",
       "death                     False\n",
       "other_aid                 False\n",
       "infrastructure_related    False\n",
       "transport                 False\n",
       "buildings                 False\n",
       "electricity               False\n",
       "tools                     False\n",
       "hospitals                 False\n",
       "shops                     False\n",
       "aid_centers               False\n",
       "other_infrastructure      False\n",
       "weather_related           False\n",
       "floods                    False\n",
       "storm                     False\n",
       "fire                      False\n",
       "earthquake                False\n",
       "cold                      False\n",
       "other_weather             False\n",
       "direct_report             False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isna().any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.dropna(subset=['related'], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id                         True\n",
       "message                   False\n",
       "original                   True\n",
       "genre                     False\n",
       "related                   False\n",
       "request                   False\n",
       "offer                     False\n",
       "aid_related               False\n",
       "medical_help              False\n",
       "medical_products          False\n",
       "search_and_rescue         False\n",
       "security                  False\n",
       "military                  False\n",
       "child_alone               False\n",
       "water                     False\n",
       "food                      False\n",
       "shelter                   False\n",
       "clothing                  False\n",
       "money                     False\n",
       "missing_people            False\n",
       "refugees                  False\n",
       "death                     False\n",
       "other_aid                 False\n",
       "infrastructure_related    False\n",
       "transport                 False\n",
       "buildings                 False\n",
       "electricity               False\n",
       "tools                     False\n",
       "hospitals                 False\n",
       "shops                     False\n",
       "aid_centers               False\n",
       "other_infrastructure      False\n",
       "weather_related           False\n",
       "floods                    False\n",
       "storm                     False\n",
       "fire                      False\n",
       "earthquake                False\n",
       "cold                      False\n",
       "other_weather             False\n",
       "direct_report             False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isna().any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# X = df.iloc[:,2]\n",
    "# Y = df.iloc[:,4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.loc[:, 'message']\n",
    "Y = df.iloc[:, 4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Weather update - a cold front from Cuba that could pass over Haiti',\n",
       "       'Is the Hurricane over or is it not over',\n",
       "       'Looking for someone but no name', ...,\n",
       "       \"Proshika, operating in Cox's Bazar municipality and 5 other unions, Ramu and Chokoria, assessment, 5 kg rice, 1,5 kg lentils to 700 families.\",\n",
       "       'Some 2,000 women protesting against the conduct of the elections were teargassed as they tried to converge on the local electoral commission offices in the southern oil city of Port Harcourt.',\n",
       "       'A radical shift in thinking came about as a result of this meeting, recognizing that HIV/AIDS is at the core of the humanitarian crisis and identifying the crisis itself as a function of the HIV/AIDS pandemic.'],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-5872fdce02a3>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-11-5872fdce02a3>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    for text in X.values:.str.split().apply(len).value_counts()\u001b[0m\n\u001b[0m                         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for text in X.values:.str.split().apply(len).value_counts()\n",
    "    print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f1209c03fd0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.matshow(Y.corr())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y['request'] = Y['request'].astype('int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Write a tokenization function to process your text data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop_words = stopwords.words('english')\n",
    "lemmatizer = WordNetLemmatizer()\n",
    "url_regex = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# starting verbs extractor\n",
    "class StartingVerbExtractor(BaseEstimator, TransformerMixin):\n",
    "\n",
    "    @staticmethod\n",
    "    def starting_verb(text):\n",
    "        sentence_list = nltk.sent_tokenize(text)\n",
    "        for sentence in sentence_list:\n",
    "            pos_tags = nltk.pos_tag(tokenize_text(sentence))\n",
    "            if len(pos_tags) != 0:\n",
    "                first_word, first_tag = pos_tags[0]\n",
    "                if first_tag in ['VB', 'VBP']:\n",
    "                    return True\n",
    "        return False\n",
    "\n",
    "    def fit(self, x, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        X_tagged = pd.Series(X).apply(self.starting_verb)\n",
    "        return pd.DataFrame(X_tagged)\n",
    "\n",
    "\n",
    "class VerbCountExtractor(BaseEstimator, TransformerMixin):\n",
    "\n",
    "    @staticmethod\n",
    "    def count_verbs(text):\n",
    "        total_verbs = 0\n",
    "        pos_tags = nltk.pos_tag(tokenize_text(text))\n",
    "        for word, tag in pos_tags:\n",
    "            if tag in ['VB', 'VBP', 'VBD']:\n",
    "                total_verbs = total_verbs + 1\n",
    "\n",
    "        return total_verbs\n",
    "\n",
    "    def fit(self, x, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        X_tagged = pd.Series(X).apply(self.count_verbs)\n",
    "        return pd.DataFrame(X_tagged)\n",
    "\n",
    "\n",
    "class NounCountExtractor(BaseEstimator, TransformerMixin):\n",
    "    @staticmethod\n",
    "    def count_nouns(text):\n",
    "        total_nouns = 0\n",
    "        pos_tags = nltk.pos_tag(tokenize_text(text))\n",
    "        for word, tag in pos_tags:\n",
    "            if tag in ['NN', 'NNS', 'NNPS', 'NNP']:\n",
    "                total_nouns = total_nouns + 1\n",
    "\n",
    "        return total_nouns\n",
    "\n",
    "    def fit(self, x, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        X_tagged = pd.Series(X).apply(self.count_nouns)\n",
    "        return pd.DataFrame(X_tagged)\n",
    "\n",
    "\n",
    "class StartingModalExtractor(BaseEstimator, TransformerMixin):\n",
    "    @staticmethod\n",
    "    def starting_modals(text):\n",
    "        sentence_list = nltk.sent_tokenize(text)\n",
    "        for sentence in sentence_list:\n",
    "            pos_tags = nltk.pos_tag(tokenize_text(sentence))\n",
    "            if len(pos_tags) != 0:\n",
    "                first_word, first_tag = pos_tags[0]\n",
    "                if first_tag == 'MD':\n",
    "                    return True\n",
    "        return False\n",
    "\n",
    "    def fit(self, x, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        X_tagged = pd.Series(X).apply(self.starting_modals)\n",
    "        return pd.DataFrame(X_tagged)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize_text(text):\n",
    "    \"\"\"\n",
    "        Apply case normalization, lemmatize and tokenize text.\n",
    "\n",
    "        INPUT:\n",
    "            text -- text in source format\n",
    "        OUTPUT:\n",
    "            clean_tokens -- cleaned tokenized list\n",
    "    \"\"\"\n",
    "\n",
    "    # transform to lower case\n",
    "    text = text.lower()\n",
    "    # remove urls\n",
    "    text = re.sub(url_regex, \" \", text)\n",
    "    # remove punctuations\n",
    "    text = re.sub(r\"[^A-Za-z0-9]+\", \" \", text)\n",
    "    # remove numbers\n",
    "    text = re.sub(r\"\\d+\", \" \", text)\n",
    "    # tokenize for words\n",
    "    words = word_tokenize(text)\n",
    "    # Remove stop words\n",
    "    tokens = [w for w in words if w not in stopwords.words(\"english\")]\n",
    "    # lemmatize the tokens\n",
    "    clean_tokens = list(map(lambda token: lemmatizer.lemmatize(token).strip(), tokens))\n",
    "    return clean_tokens\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Build a machine learning pipeline\n",
    "This machine pipeline should take in the `message` column as input and output classification results on the other 36 categories in the dataset. You may find the [MultiOutputClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.multioutput.MultiOutputClassifier.html) helpful for predicting multiple target variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_pipeline(estimator):\n",
    "    \"\"\"\n",
    "    This separate function can be used to test with multiple estimators.\n",
    "    INPUT:\n",
    "        estimator - An estimator that is used to build `sklearn.pipeline` Pipeline\n",
    "\n",
    "    OUTPUT:\n",
    "        pipeline - `sklearn.pipeline` with a estimator and multiple features.\n",
    "    \"\"\"\n",
    "\n",
    "    # define pipeline\n",
    "    pipeline = Pipeline([\n",
    "        ('features', FeatureUnion([\n",
    "            ('text_pipeline', Pipeline([\n",
    "                ('vect', CountVectorizer(tokenizer=tokenize_text)),\n",
    "                ('tfidf', TfidfTransformer())\n",
    "            ])),\n",
    "            ('starting_verb_noun', StartingVerbExtractor()),\n",
    "            ('count_verbs', VerbCountExtractor()),\n",
    "            ('count_nouns', NounCountExtractor()),\n",
    "            ('starting_modals', StartingModalExtractor())\n",
    "        ])),\n",
    "\n",
    "        ('clf', estimator)\n",
    "    ])\n",
    "\n",
    "    return pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Train pipeline\n",
    "- Split data into train and test sets\n",
    "- Train pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y,test_size = 0.2, random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "multi_label_estimators = []\n",
    "multi_label_estimator1 = MultiOutputClassifier(OneVsRestClassifier(SGDClassifier(loss='modified_huber', penalty='elasticnet',\n",
    "                                          alpha=1e-4,  random_state=42,\n",
    "                                          shuffle=True, n_jobs=5)))\n",
    "multi_label_estimators.append(multi_label_estimator1)\n",
    "\n",
    "multi_label_estimator2 = MultiOutputClassifier(OneVsRestClassifier(MultinomialNB()))\n",
    "multi_label_estimators.append(multi_label_estimator2)\n",
    "\n",
    "multi_label_estimator3 = MultiOutputClassifier(OneVsRestClassifier(LogisticRegression(solver='sag'), n_jobs=5))\n",
    "multi_label_estimators.append(multi_label_estimator3)\n",
    "\n",
    "multi_label_estimator4 = MultiOutputClassifier(OneVsRestClassifier(RandomForestClassifier(n_jobs = 5)))\n",
    "multi_label_estimators.append(multi_label_estimator4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Test your model\n",
    "Report the f1 score, precision and recall for each output category of the dataset. You can do this by iterating through the columns and calling sklearn's `classification_report` on each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i , estimator in enumerate(multi_label_estimators):\n",
    "    pipeline = build_pipeline(estimator)\n",
    "    pipeline.fit(X_train, Y_train)\n",
    "    prediction = pipeline.predict(X_test)\n",
    "    print(classification_report(Y_test, prediction, target_names=Y.columns.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimator = MultiOutputClassifier(OneVsRestClassifier(RandomForestClassifier(n_jobs = 5)))\n",
    "pipeline = build_pipeline(estimator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sajith/Documents/Acedamic/Projects/Python3.6/lib/python3.6/site-packages/sklearn/multiclass.py:75: UserWarning: Label not 0.0 is present in all training examples.\n",
      "  str(classes[c]))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "         steps=[('features',\n",
       "                 FeatureUnion(n_jobs=None,\n",
       "                              transformer_list=[('text_pipeline',\n",
       "                                                 Pipeline(memory=None,\n",
       "                                                          steps=[('vect',\n",
       "                                                                  CountVectorizer(analyzer='word',\n",
       "                                                                                  binary=False,\n",
       "                                                                                  decode_error='strict',\n",
       "                                                                                  dtype=<class 'numpy.int64'>,\n",
       "                                                                                  encoding='utf-8',\n",
       "                                                                                  input='content',\n",
       "                                                                                  lowercase=True,\n",
       "                                                                                  max_df=1.0,\n",
       "                                                                                  max_features=None,\n",
       "                                                                                  min_df=1,\n",
       "                                                                                  ngram_range=(1,\n",
       "                                                                                               1),\n",
       "                                                                                  preprocessor=Non...\n",
       "                                                                                                      class_weight=None,\n",
       "                                                                                                      criterion='gini',\n",
       "                                                                                                      max_depth=None,\n",
       "                                                                                                      max_features='auto',\n",
       "                                                                                                      max_leaf_nodes=None,\n",
       "                                                                                                      max_samples=None,\n",
       "                                                                                                      min_impurity_decrease=0.0,\n",
       "                                                                                                      min_impurity_split=None,\n",
       "                                                                                                      min_samples_leaf=1,\n",
       "                                                                                                      min_samples_split=2,\n",
       "                                                                                                      min_weight_fraction_leaf=0.0,\n",
       "                                                                                                      n_estimators=100,\n",
       "                                                                                                      n_jobs=5,\n",
       "                                                                                                      oob_score=False,\n",
       "                                                                                                      random_state=None,\n",
       "                                                                                                      verbose=0,\n",
       "                                                                                                      warm_start=False),\n",
       "                                                                     n_jobs=None),\n",
       "                                       n_jobs=None))],\n",
       "         verbose=False)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipeline.fit(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction = pipeline.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                        precision    recall  f1-score   support\n",
      "\n",
      "               related       0.83      0.96      0.89      3983\n",
      "               request       0.86      0.51      0.64       931\n",
      "                 offer       0.00      0.00      0.00        20\n",
      "           aid_related       0.77      0.70      0.73      2226\n",
      "          medical_help       0.74      0.06      0.12       447\n",
      "      medical_products       0.75      0.12      0.20       284\n",
      "     search_and_rescue       0.62      0.05      0.09       170\n",
      "              security       0.50      0.01      0.02       104\n",
      "              military       0.86      0.06      0.12       189\n",
      "           child_alone       0.00      0.00      0.00         0\n",
      "                 water       0.91      0.37      0.52       371\n",
      "                  food       0.84      0.63      0.72       597\n",
      "               shelter       0.80      0.42      0.55       477\n",
      "              clothing       0.82      0.12      0.20        77\n",
      "                 money       0.67      0.02      0.03       112\n",
      "        missing_people       0.00      0.00      0.00        68\n",
      "              refugees       0.20      0.01      0.02       167\n",
      "                 death       0.85      0.16      0.27       245\n",
      "             other_aid       0.79      0.04      0.07       715\n",
      "infrastructure_related       1.00      0.01      0.01       343\n",
      "             transport       0.78      0.07      0.13       247\n",
      "             buildings       0.87      0.13      0.23       258\n",
      "           electricity       1.00      0.02      0.04       103\n",
      "                 tools       0.00      0.00      0.00        36\n",
      "             hospitals       0.00      0.00      0.00        57\n",
      "                 shops       0.00      0.00      0.00        18\n",
      "           aid_centers       0.00      0.00      0.00        67\n",
      "  other_infrastructure       0.00      0.00      0.00       229\n",
      "       weather_related       0.86      0.69      0.76      1489\n",
      "                floods       0.95      0.38      0.54       434\n",
      "                 storm       0.76      0.48      0.59       505\n",
      "                  fire       1.00      0.04      0.07        56\n",
      "            earthquake       0.89      0.82      0.85       509\n",
      "                  cold       0.58      0.07      0.12       107\n",
      "         other_weather       0.56      0.03      0.06       277\n",
      "         direct_report       0.79      0.38      0.51      1029\n",
      "\n",
      "             micro avg       0.82      0.53      0.65     16947\n",
      "             macro avg       0.61      0.20      0.25     16947\n",
      "          weighted avg       0.79      0.53      0.57     16947\n",
      "           samples avg       0.68      0.49      0.52     16947\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sajith/Documents/Acedamic/Projects/Python3.6/lib/python3.6/site-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home/sajith/Documents/Acedamic/Projects/Python3.6/lib/python3.6/site-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Recall and F-score are ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home/sajith/Documents/Acedamic/Projects/Python3.6/lib/python3.6/site-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in samples with no predicted labels. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home/sajith/Documents/Acedamic/Projects/Python3.6/lib/python3.6/site-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Recall and F-score are ill-defined and being set to 0.0 in samples with no true labels. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(Y_test, prediction, target_names=Y.columns.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(pipeline, open('classifier.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "estimator.get_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Improve your model\n",
    "Use grid search to find better parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = {\n",
    "        'features__text_pipeline__vect__ngram_range': ((1, 1), (1, 2)),\n",
    "        'features__text_pipeline__vect__max_df': (0.5, 0.75, 1.0),\n",
    "        'features__text_pipeline__vect__max_features': (None, 10, 100),\n",
    "        'features__text_pipeline__tfidf__use_idf': (True, False),\n",
    "        'clf__estimator__estimator__n_estimators': [100, 200, 1000],\n",
    "        'clf__estimator__estimator__min_samples_split': [2, 3, 4],\n",
    "        'features__transformer_weights': (\n",
    "            {'text_pipeline': 1, 'starting_verb': 0.5},\n",
    "            {'text_pipeline': 0.5, 'starting_verb': 1},\n",
    "            {'text_pipeline': 0.8, 'starting_verb': 1},\n",
    "        )\n",
    "    }\n",
    "cv = GridSearchCV(pipeline, param_grid = parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv.fit(X_train,Y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Test your model\n",
    "Show the accuracy, precision, and recall of the tuned model.  \n",
    "\n",
    "Since this project focuses on code quality, process, and  pipelines, there is no minimum performance metric needed to pass. However, make sure to fine tune your models for accuracy, precision and recall to make your project stand out - especially for your portfolio!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Try improving your model further. Here are a few ideas:\n",
    "* try other machine learning algorithms\n",
    "* add other features besides the TF-IDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Export your model as a pickle file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Use this notebook to complete `train.py`\n",
    "Use the template file attached in the Resources folder to write a script that runs the steps above to create a database and export a model based on a new dataset specified by the user."
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}