notebooks/modeling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Screenplay Genre Classifier\n",
    "\n",
    "## Model Building\n",
    "\n",
    "In this section, I test out different feature extration techinques as well as different multilabel classification algorithims. They are saved to a dictionary which I then use to observe the average hamming loss of each model. I chose hamming loss as the metric to measure the integrity of my models because it takes the fraction of wrong labels to all labels. This is ideal in my case because there are simialrieites between genres like Action and Adventure where the classifier could confuse one for another. Aditionally, it is a better measurement than accuracy because accuracy would require the whole 18 element array to be predicted correctly which seem infeasible given the scope of the project. For example, if the machine predicted 16/18 labels correctly, then the accuracy would be 0, while hamming loss would equal 0.11."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing necessary packages\n",
    "import pandas as pd\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from topicmodels import Modeling\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n",
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "from sklearn.multioutput import ClassifierChain\n",
    "from sklearn.metrics import hamming_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loading in training and testing data\n",
    "X_train = pd.read_csv('data/X_train.csv', index_col=[0])\n",
    "X_test = pd.read_csv('data/X_test.csv', index_col=[0])\n",
    "y_train = pd.read_csv('data/y_train.csv', index_col=[0])\n",
    "y_test = pd.read_csv('data/y_test.csv', index_col=[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "models_dct = {'model': [], 'hamming_loss': [], 'model_type': []} #initalizing dictonary to store results\n",
    "\n",
    "def model_update(model, dct, model_type):\n",
    "\n",
    "    \"\"\"\n",
    "    This function takes in a fitted model, dictionary, and descirpition of the model.\n",
    "    It returns an updated dictonary that will later be used to evaluate model results.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    y_pred = model.predict(X_test.text)\n",
    "\n",
    "    ham_loss = hamming_loss(y_test, y_pred)\n",
    "\n",
    "    models_dct['model'].append(model)\n",
    "    models_dct['hamming_loss'].append(ham_loss)\n",
    "    models_dct['model_type'].append(model_type)\n",
    "\n",
    "    print(ham_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.concat([X_train, y_train], axis=1)\n",
    "df_train.dropna(inplace=True) #delete this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.concat([X_test, y_test], axis=1)\n",
    "df_test.dropna(inplace=True) #delete this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = df_train.loc[:, ['text', 'title']]\n",
    "y_train = df_train.drop(columns=['text', 'title'], axis=1)\n",
    "\n",
    "X_test = df_test.loc[:, ['text', 'title']]\n",
    "y_test = df_test.drop(columns=['text', 'title'], axis=1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Section: Model Building\n",
    "\n",
    "I trade off between CountVecotrizer and TfidfVectorizer with various multilclassifier  combinations to optimize hamming_loss score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12007168458781362\n"
     ]
    }
   ],
   "source": [
    "#countvecotrizer, classifier chain, logistic regression\n",
    "\n",
    "pipe = Pipeline([('cv', CountVectorizer()), ('model', ClassifierChain(LogisticRegression()))])\n",
    "pipe.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe, models_dct, 'CC with CV and LG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1370496132805131\n"
     ]
    }
   ],
   "source": [
    "#tfidvecotrizer, classifier chain, logistic regression\n",
    "\n",
    "pipe_tf_cc = Pipeline([('tf', TfidfVectorizer()), ('model', ClassifierChain(LogisticRegression()))])\n",
    "pipe_tf_cc.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_tf_cc, models_dct, 'CC with TF and LG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12299566119600075\n"
     ]
    }
   ],
   "source": [
    "\n",
    "pipe_cv_cc_rf = Pipeline([('cv', CountVectorizer()), ('model', ClassifierChain(RandomForestClassifier()))])\n",
    "pipe_cv_cc_rf.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_cv_cc_rf, models_dct, 'CC with CV and RF')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12242973023957744\n"
     ]
    }
   ],
   "source": [
    "pipe_three = Pipeline([('cv', TfidfVectorizer()), ('model', ClassifierChain(RandomForestClassifier()))])\n",
    "pipe_three.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_three, models_dct, 'CC with Tf and RF')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.11450669684965101\n"
     ]
    }
   ],
   "source": [
    "pipe_four = Pipeline([('cv', CountVectorizer()), ('model', ClassifierChain(GradientBoostingClassifier()))])\n",
    "pipe_four.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_four, models_dct, 'CC with CV and GBC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12299566119600075\n"
     ]
    }
   ],
   "source": [
    "pipe_five = Pipeline([('cv', TfidfVectorizer()), ('model', ClassifierChain(GradientBoostingClassifier()))])\n",
    "pipe_five.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_cv_cc_rf, models_dct, 'CC with CV and RF')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12073193737030749\n"
     ]
    }
   ],
   "source": [
    "pipe_six = Pipeline([('cv', CountVectorizer()), ('model', OneVsRestClassifier(LogisticRegression()))])\n",
    "pipe_six.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_six, models_dct, 'OVR with CV and LG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12073193737030749\n"
     ]
    }
   ],
   "source": [
    "pipe_seven = Pipeline([('cv', TfidfVectorizer()), ('model', OneVsRestClassifier(LogisticRegression()))])\n",
    "pipe_seven.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_six, models_dct, 'OVR with TF and LG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12280701754385964\n"
     ]
    }
   ],
   "source": [
    "pipe_eight = Pipeline([('cv', CountVectorizer()), ('model', OneVsRestClassifier(RandomForestClassifier()))])\n",
    "pipe_eight.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_eight, models_dct, 'OVR with CV and Rf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12280701754385964\n"
     ]
    }
   ],
   "source": [
    "pipe_nine = Pipeline([('cv', TfidfVectorizer()), ('model', OneVsRestClassifier(RandomForestClassifier()))])\n",
    "pipe_nine.fit(X_train.text, y_train)\n",
    "\n",
    "model_update(pipe_eight, models_dct, 'OVR with TV and Rf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second Section: Evaluating Results between Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#saving dct as a dataframe\n",
    "model_data = pd.DataFrame(models_dct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing necessary packages for visualizations\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "ham = model_data.sort_values(by='hamming_loss').hamming_loss\n",
    "mt = model_data.sort_values(by='hamming_loss').model_type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\seaborn\\_decorators.py:36: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting avg ham loss of models\n",
    "fig, ax = plt.subplots(figsize=(20,12))\n",
    "\n",
    "sns.barplot(ham, list(range(len(ham))), orient='h', ax=ax)\n",
    "\n",
    "ax.set_yticks(list(range(len(ham))))\n",
    "ax.set_yticklabels(mt)\n",
    "\n",
    "ax.set_title('Average Hamming Loss between Model Types', fontsize=30, pad=15)\n",
    "ax.set_xlabel('Hamming Loss', fontsize=15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Third Section: Evaluating Best Model's predictions\n",
    "\n",
    "In this section, I evaluate the ClassifierChain with base estimator as GradientBoostingClassifier and CountVectorizer as the feature. I look at average ham loss by genre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "y_pred = pipe_four.predict(X_test.text) #predictions on best model\n",
    "\n",
    "dct = {'title': [], 'real': [], 'pred': []}\n",
    "\n",
    "for i in range(len(y_test)):\n",
    "\n",
    "    dct['real'].append(np.array(y_test.iloc[i]))\n",
    "    dct['pred'].append(y_pred[i])\n",
    "    dct['title'].append(X_test.title.iloc[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = pd.DataFrame(dct, index=X_test.index) #converting dct to dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labeller(arry):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function converts predicted array to list of genres\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    lst = []\n",
    "\n",
    "    for i, x in enumerate(arry):\n",
    "        if x ==1:\n",
    "            lst.append(genre_list[i])\n",
    "\n",
    "    return lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions['actual'] = predictions.real.apply(lambda x: labeller(x)) #actual genres\n",
    "predictions['predicted'] = predictions.pred.apply(lambda x: labeller(x)) #predicted genres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "ham_loss = [] #appending ham_loss by single row\n",
    "\n",
    "for i in predictions.index:\n",
    "    ham_loss.append(hamming_loss(predictions.real[i], predictions.pred[i]))\n",
    "\n",
    "predictions['ham_loss'] = ham_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def genre_enocoding(row, genre):\n",
    "\n",
    "    \"\"\"\n",
    "    One hot encodes prediction dataframe\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    if genre in row:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in genre_list:\n",
    "    predictions[i] = predictions.actual.apply(lambda x: genre_enocoding(x, i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "ham_loss_by_genre = [] #appending avg_ham_loss by genre\n",
    "for i in genre_list:\n",
    "    ham_loss_by_genre.append(predictions[predictions[i] == 1].ham_loss.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mikey\\anaconda3\\envs\\contest_env\\lib\\site-packages\\seaborn\\_decorators.py:36: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting average ham loss by genre\n",
    "fig, ax = plt.subplots(figsize=(20,12))\n",
    "\n",
    "sns.barplot(list(range(0,18)), ham_loss_by_genre)\n",
    "ax.set_title(\"Average Hamming Loss by Genre\", fontsize=30)\n",
    "ax.set_xticks(list(range(0,18)))\n",
    "ax.set_xticklabels(genre_list, fontsize=15, rotation=40)\n",
    "ax.set_ylabel('Hamming Loss', fontsize=15)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions['genre_length'] = predictions.actual.apply(lambda x: len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Avgerage Hamming Loss by Genre Combination'}, ylabel='genre_length'>"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "predictions.groupby(['genre_length'])['ham_loss'].mean().plot(kind='barh', figsize=(15,8), title='Avgerage Hamming Loss by Genre Combination')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (contest)",
   "language": "python",
   "name": "contest_env"
  },
  "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.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}