3. Classification on Text Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Classification-on-text-data\" data-toc-modified-id=\"Classification-on-text-data-1\">Classification on text data</a></span><ul class=\"toc-item\"><li><span><a href=\"#Import-the-text-data\" data-toc-modified-id=\"Import-the-text-data-1.1\">Import the text data</a></span></li><li><span><a href=\"#Vectorize\" data-toc-modified-id=\"Vectorize-1.2\">Vectorize</a></span></li><li><span><a href=\"#Run-three-models-and-Select\" data-toc-modified-id=\"Run-three-models-and-Select-1.3\">Run three models and Select</a></span><ul class=\"toc-item\"><li><span><a href=\"#a)-KNN\" data-toc-modified-id=\"a)-KNN-1.3.1\">a) KNN</a></span></li><li><span><a href=\"#b)-Penalized-Logistic-regression\" data-toc-modified-id=\"b)-Penalized-Logistic-regression-1.3.2\">b) Penalized Logistic regression</a></span></li><li><span><a href=\"#c)-Bagged-Tree\" data-toc-modified-id=\"c)-Bagged-Tree-1.3.3\">c) Bagged Tree</a></span></li></ul></li><li><span><a href=\"#Inspect-all-models-by-visualizing-the-coefficients.\" data-toc-modified-id=\"Inspect-all-models-by-visualizing-the-coefficients.-1.4\">Inspect all models by visualizing the coefficients.</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification on text data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import the text data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda/envs/ml/lib/python3.7/site-packages/sklearn/utils/__init__.py:4: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Sequence\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16985,)\n",
      "(5657,)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.datasets import load_files\n",
    "\n",
    "train = pd.read_csv(\"./Text_train_data.csv\")\n",
    "test = pd.read_csv(\"./Text_test_data.csv\")\n",
    "\n",
    "text_train, y_train = train.Review, train.Recommended\n",
    "text_test, y_test = test.Review, test.Recommended\n",
    "\n",
    "\n",
    "\n",
    "print(y_train.shape)\n",
    "print(y_test.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Review</th>\n",
       "      <th>Recommended</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>\"go to\" please offer a maxi for mature custome...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>\"go to\" tee for sz 10+ women.Women who want so...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>\"long and warm\".These leg warmers are perfect ...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>\"tweed\" dress.I bought this dress for my siste...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>#1 stunna.I am in lust with this fabulous dres...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              Review  Recommended\n",
       "0  \"go to\" please offer a maxi for mature custome...            1\n",
       "1  \"go to\" tee for sz 10+ women.Women who want so...            1\n",
       "2  \"long and warm\".These leg warmers are perfect ...            1\n",
       "3  \"tweed\" dress.I bought this dress for my siste...            1\n",
       "4  #1 stunna.I am in lust with this fabulous dres...            1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    13910\n",
       "0     3075\n",
       "Name: Recommended, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['Recommended'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "vect = CountVectorizer().fit(text_train)\n",
    "X_train = vect.transform(text_train)\n",
    "X_test = vect.transform(text_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      "<16985x13010 sparse matrix of type '<class 'numpy.int64'>'\n",
      "\twith 749166 stored elements in Compressed Sparse Row format>\n"
     ]
    }
   ],
   "source": [
    "print(\"X:\\n{}\".format(repr(X_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "        strip_accents=None, token_pattern='(?u)\\\\b\\\\w\\\\w+\\\\b',\n",
       "        tokenizer=None, vocabulary=None)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of features: 13010\n",
      "First 20 features:\n",
      "['00', '000', '00p', '03', '03dd', '04', '06', '0dd', '0in', '0p', '0petite', '0r', '0xs', '10', '100', '1000', '100lb', '100lbs', '102', '102lbs']\n",
      "Features 210 to 230:\n",
      "['1st', '1x', '20', '200', '2000s', '2001', '2004', '2005', '2006', '2007', '2008', '2010', '2012', '2013', '2015', '2016', '2035', '20lb', '20lbs', '20s']\n",
      "Every 200th feature:\n",
      "['00', '1970', '56', 'actualyl', 'altar', 'area', 'awsome', 'beforehand', 'blossoms', 'breastfeeding', 'buttoning', 'cedar', 'circle', 'combat', 'constructed', 'cream', 'darkler', 'designed', 'dissapointing', 'dropped', 'embroiderer', 'excellently', 'fashioned', 'flaring', 'former', 'gauze', 'graphic', 'havne', 'hoodie', 'imperfection', 'interfered', 'july', 'las', 'limiting', 'lucky', 'matte', 'minor', 'mum', 'nimble', 'ombrã', 'overtime', 'peek', 'pinstripe', 'possessing', 'promised', 'rail', 'regualr', 'retailerpolog', 'rt', 'scratches', 'shapewear', 'sill', 'slumpy', 'spaghetti', 'steaming', 'stunned', 'sways', 'tell', 'ticket', 'trapeze', 'unacceptable', 'unusial', 'vita', 'well', 'words', 'zips']\n"
     ]
    }
   ],
   "source": [
    "feature_names = vect.get_feature_names()\n",
    "print(\"Number of features: {}\".format(len(feature_names)))\n",
    "print(\"First 20 features:\\n{}\".format(feature_names[:20]))\n",
    "print(\"Features 210 to 230:\\n{}\".format(feature_names[210:230]))\n",
    "print(\"Every 200th feature:\\n{}\".format(feature_names[::200]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Run three models and Select"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score: 0.824\n",
      "Best parameters:  {'n_neighbors': 7}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import numpy as np\n",
    "\n",
    "kparam_grid = {'n_neighbors': np.arange(1, 9, 2)} \n",
    "kgrid = GridSearchCV(KNeighborsClassifier(), kparam_grid, n_jobs =-1)\n",
    "kgrid.fit(X_train, y_train)\n",
    "print(\"Best cross-validation score: {:.3f}\".format(kgrid.best_score_))\n",
    "print(\"Best parameters: \", kgrid.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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>Predicted Not Recommend</th>\n",
       "      <th>Predicted Recommend</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>True Not Recommend</th>\n",
       "      <td>215</td>\n",
       "      <td>811</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>True Recommend</th>\n",
       "      <td>158</td>\n",
       "      <td>4473</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Predicted Not Recommend  Predicted Recommend\n",
       "True Not Recommend                      215                  811\n",
       "True Recommend                          158                 4473"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.58      0.21      0.31      1026\n",
      "          1       0.85      0.97      0.90      4631\n",
      "\n",
      "avg / total       0.80      0.83      0.79      5657\n",
      "\n",
      "overall accuracy: 0.89889\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=7)\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# predictions\n",
    "knn_pred = knn.predict(X_test) \n",
    "\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "display(pd.DataFrame(\n",
    "    confusion_matrix(y_test, knn_pred),\n",
    "    columns=['Predicted Not Recommend', 'Predicted Recommend'],\n",
    "    index=['True Not Recommend', 'True Recommend']\n",
    "))\n",
    "\n",
    "# classification_report matrix \n",
    "print(classification_report(y_test, knn_pred))  \n",
    "\n",
    "\n",
    "# percent of correct prediction\n",
    "print(\"overall accuracy: {:.5f}\".format(plr.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Penalized Logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean cross-validation accuracy: 0.893\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "scores = cross_val_score(LogisticRegression(), X_train, y_train, cv=5)\n",
    "print(\"Mean cross-validation accuracy: {:.3f}\".format(np.mean(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score: 0.898\n",
      "Best parameters:  {'C': 0.1}\n"
     ]
    }
   ],
   "source": [
    "param_grid = {'C': [0.001, 0.01, 0.1, 1, 10]}\n",
    "grid = GridSearchCV(LogisticRegression(), param_grid, cv=5)\n",
    "grid.fit(X_train, y_train)\n",
    "print(\"Best cross-validation score: {:.3f}\".format(grid.best_score_))\n",
    "print(\"Best parameters: \", grid.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test score: 0.899\n"
     ]
    }
   ],
   "source": [
    "print(\"Test score: {:.3f}\".format(grid.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# initialize model\n",
    "plr = LogisticRegression(C=0.1)\n",
    "plr.fit(X_train, y_train)\n",
    "\n",
    "# predictions\n",
    "plr_pred = plr.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": false
   },
   "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>Predicted Not Recommend</th>\n",
       "      <th>Predicted Recommend</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>True Not Recommend</th>\n",
       "      <td>675</td>\n",
       "      <td>351</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>True Recommend</th>\n",
       "      <td>221</td>\n",
       "      <td>4410</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Predicted Not Recommend  Predicted Recommend\n",
       "True Not Recommend                      675                  351\n",
       "True Recommend                          221                 4410"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.75      0.66      0.70      1026\n",
      "          1       0.93      0.95      0.94      4631\n",
      "\n",
      "avg / total       0.89      0.90      0.90      5657\n",
      "\n",
      "overall accuracy: 0.89889\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "display(pd.DataFrame(\n",
    "    confusion_matrix(y_test, plr_pred),\n",
    "    columns=['Predicted Not Recommend', 'Predicted Recommend'],\n",
    "    index=['True Not Recommend', 'True Recommend']\n",
    "))\n",
    "\n",
    "# classification_report matrix \n",
    "print(classification_report(y_test, plr_pred))  \n",
    "\n",
    "\n",
    "# percent of correct prediction\n",
    "print(\"overall accuracy: {:.5f}\".format(plr.score(X_test, y_test)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) Bagged Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda/envs/ml/lib/python3.7/site-packages/sklearn/ensemble/weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean cross-validation accuracy: 0.855\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "tree = DecisionTreeClassifier() \n",
    "bag = BaggingClassifier(tree)\n",
    "\n",
    "scores = cross_val_score(bag, X_train, y_train, cv=5)\n",
    "print(\"Mean cross-validation accuracy: {:.3f}\".format(np.mean(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score: 0.830\n",
      "Best parameters:  {'base_estimator__max_depth': 5, 'max_samples': 0.2}\n"
     ]
    }
   ],
   "source": [
    "param_grid = {\n",
    "    'base_estimator__max_depth' : [1, 2, 3, 4, 5],\n",
    "    'max_samples' : [0.05, 0.1, 0.2, 0.5]\n",
    "}\n",
    "\n",
    "clf = GridSearchCV(BaggingClassifier(DecisionTreeClassifier(),\n",
    "                                     n_estimators = 100, max_features = 0.5),\n",
    "                   param_grid, n_jobs =-1)\n",
    "\n",
    "clf.fit(X_train, y_train)\n",
    "print(\"Best cross-validation score: {:.3f}\".format(clf.best_score_))\n",
    "print(\"Best parameters: \", clf.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "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>Predicted Not Recommend</th>\n",
       "      <th>Predicted Recommend</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>True Not Recommend</th>\n",
       "      <td>73</td>\n",
       "      <td>953</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>True Recommend</th>\n",
       "      <td>12</td>\n",
       "      <td>4619</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Predicted Not Recommend  Predicted Recommend\n",
       "True Not Recommend                       73                  953\n",
       "True Recommend                           12                 4619"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.86      0.07      0.13      1026\n",
      "          1       0.83      1.00      0.91      4631\n",
      "\n",
      "avg / total       0.83      0.83      0.77      5657\n",
      "\n",
      "overall accuracy: 0.89889\n"
     ]
    }
   ],
   "source": [
    "tree = DecisionTreeClassifier(max_depth = 5)\n",
    "bag = BaggingClassifier(tree,n_estimators = 100, max_features = 0.5,  max_samples = 0.2)\n",
    "\n",
    "bag.fit(X_train,y_train)\n",
    "\n",
    "bag_pred = bag.predict(X_test)\n",
    "\n",
    "display(pd.DataFrame(\n",
    "    confusion_matrix(y_test, bag_pred),\n",
    "    columns=['Predicted Not Recommend', 'Predicted Recommend'],\n",
    "    index=['True Not Recommend', 'True Recommend']\n",
    "))\n",
    "\n",
    "# classification_report matrix \n",
    "print(classification_report(y_test, bag_pred))  \n",
    "\n",
    "\n",
    "# percent of correct prediction\n",
    "print(\"overall accuracy: {:.5f}\".format(plr.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*I choose the Penalized Logistic regression because this model perform best in terms of positive and negtive case classification (highest F1 score)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inspect all models by visualizing the coefficients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# helper function to plot top positive and negative coefficients\n",
    "\n",
    "def visualize_coefficients(coefficients, feature_names, n_top_features=25):\n",
    "    \"\"\"Visualize coefficients of a linear model.\n",
    "    Parameters\n",
    "    ----------\n",
    "    coefficients : nd-array, shape (n_features,)\n",
    "        Model coefficients.\n",
    "    feature_names : list or nd-array of strings, shape (n_features,)\n",
    "        Feature names for labeling the coefficients.\n",
    "    n_top_features : int, default=25\n",
    "        How many features to show. The function will show the largest (most\n",
    "        positive) and smallest (most negative)  n_top_features coefficients,\n",
    "        for a total of 2 * n_top_features coefficients.\n",
    "    \"\"\"\n",
    "    coefficients = coefficients.squeeze()\n",
    "    if coefficients.ndim > 1:\n",
    "        # this is not a row or column vector\n",
    "        raise ValueError(\"coeffients must be 1d array or column vector, got\"\n",
    "                         \" shape {}\".format(coefficients.shape))\n",
    "    coefficients = coefficients.ravel()\n",
    "\n",
    "    if len(coefficients) != len(feature_names):\n",
    "        raise ValueError(\"Number of coefficients {} doesn't match number of\"\n",
    "                         \"feature names {}.\".format(len(coefficients),\n",
    "                                                    len(feature_names)))\n",
    "    # get coefficients with large absolute values\n",
    "    coef = coefficients.ravel()\n",
    "    positive_coefficients = np.argsort(coef)[-n_top_features:]\n",
    "    negative_coefficients = np.argsort(coef)[:n_top_features]\n",
    "    interesting_coefficients = np.hstack([negative_coefficients,\n",
    "                                          positive_coefficients])\n",
    "    # plot them\n",
    "    plt.figure(figsize=(15, 5))\n",
    "    colors = ['#ff2020' if c < 0 else '#0000aa'\n",
    "              for c in coef[interesting_coefficients]]\n",
    "    plt.bar(np.arange(2 * n_top_features), coef[interesting_coefficients],\n",
    "            color=colors)\n",
    "    feature_names = np.array(feature_names)\n",
    "    plt.subplots_adjust(bottom=0.3)\n",
    "    plt.xticks(np.arange(1, 1 + 2 * n_top_features),\n",
    "               feature_names[interesting_coefficients], rotation=60,\n",
    "               ha=\"right\")\n",
    "    plt.ylabel(\"Coefficient magnitude\")\n",
    "    plt.xlabel(\"Feature\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "plr_coefs = plr.coef_\n",
    "feature_names = vect.get_feature_names()\n",
    "\n",
    "\n",
    "visualize_coefficients(plr_coefs, feature_names, n_top_features=25)"
   ]
  }
 ],
 "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.8.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}