Stackoverflow Tags Map & Model (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Answers.csv', 'Questions.csv', 'Tags.csv']\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os\n",
    "print(os.listdir(\"C://Users//Kamal//Desktop//StackOverFlow-Classification-master//stacksample\"))\n",
    "\n",
    "# Plotting Libs\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "# magic function\n",
    "%matplotlib inline\n",
    "\n",
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
   },
   "outputs": [],
   "source": [
    "df_tags = pd.read_csv('C://Users//Kamal//Desktop//StackOverFlow-Classification-master//stacksample//Tags.csv', encoding='iso-8859-1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_tags(tagCount):\n",
    "    \n",
    "    x,y = zip(*tagCount)\n",
    "\n",
    "    colormap = plt.cm.gist_ncar #nipy_spectral, Set1,Paired  \n",
    "    colors = [colormap(i) for i in np.linspace(0, 0.8,50)]   \n",
    "\n",
    "    area = [i/4000 for i in list(y)]   # 0 to 15 point radiuses\n",
    "    plt.figure(figsize=(9,8))\n",
    "    plt.ylabel(\"Number of question associations\")\n",
    "    for i in range(len(y)):\n",
    "        plt.plot(i,y[i], marker='o', linestyle='',ms=area[i],label=x[i])\n",
    "\n",
    "    plt.legend(numpoints=1)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('javascript', 124155), ('java', 115212), ('c#', 101186), ('php', 98808), ('android', 90659), ('jquery', 78542), ('python', 64601), ('html', 58976), ('c++', 47591), ('ios', 47009)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tagCount =  collections.Counter(list(df_tags['Tag'])).most_common(10)\n",
    "print(tagCount)\n",
    "plot_tags(tagCount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "top10=['javascript','java','c#','php','android','jquery','python','html','c++','ios']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(826739, 2)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Tag</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>260</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>330</td>\n",
       "      <td>c++</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>650</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>930</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>1010</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Id  Tag\n",
       "14   260   c#\n",
       "18   330  c++\n",
       "28   650   c#\n",
       "35   930   c#\n",
       "39  1010   c#"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag_top10= df_tags[df_tags.Tag.isin(top10)]\n",
    "print (tag_top10.shape)\n",
    "tag_top10.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30798790    5\n",
       "31085960    5\n",
       "11648170    5\n",
       "35318730    5\n",
       "4009250     5\n",
       "30289880    5\n",
       "23267320    5\n",
       "35283570    5\n",
       "30991580    5\n",
       "23484760    5\n",
       "Name: Id, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag_top10['Id'].value_counts().head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Tag</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>260</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>330</td>\n",
       "      <td>c++</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>650</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>930</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>1010</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Id  Tag\n",
       "14   260   c#\n",
       "18   330  c++\n",
       "28   650   c#\n",
       "35   930   c#\n",
       "39  1010   c#"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag_top10.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_tags(question_id):\n",
    "    return tag_top10[tag_top10['Id'] == question_id['Id']].Tag.values\n",
    "\n",
    "top10 = tag_top10.apply(add_tags, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(826739, (826739, 2))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(top10),tag_top10.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Tag</th>\n",
       "      <th>Tags</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>260</td>\n",
       "      <td>c#</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>330</td>\n",
       "      <td>c++</td>\n",
       "      <td>[c++]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>650</td>\n",
       "      <td>c#</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>930</td>\n",
       "      <td>c#</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>1010</td>\n",
       "      <td>c#</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Id  Tag   Tags\n",
       "14   260   c#   [c#]\n",
       "18   330  c++  [c++]\n",
       "28   650   c#   [c#]\n",
       "35   930   c#   [c#]\n",
       "39  1010   c#   [c#]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag_top10=pd.concat([tag_top10, top10.rename('Tags')], axis=1)\n",
    "tag_top10.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(826739, 2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tag_top10.drop([\"Tag\"], axis=1, inplace=True)\n",
    "tag_top10.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "top10_tags=tag_top10.loc[tag_top10.astype(str).drop_duplicates().index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Title</th>\n",
       "      <th>Body</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>80</td>\n",
       "      <td>SQLStatement.execute() - multiple queries in o...</td>\n",
       "      <td>I've written a database generation script in S...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>90</td>\n",
       "      <td>Good branching and merging tutorials for Torto...</td>\n",
       "      <td>Are there any really good tutorials explaining...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>120</td>\n",
       "      <td>ASP.NET Site Maps</td>\n",
       "      <td>Has anyone got experience creating SQL-based A...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>180</td>\n",
       "      <td>Function for creating color wheels</td>\n",
       "      <td>This is something I've pseudo-solved many time...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>260</td>\n",
       "      <td>Adding scripting functionality to .NET applica...</td>\n",
       "      <td>I have a little game written in C#. It uses a ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Id                                              Title  \\\n",
       "0   80  SQLStatement.execute() - multiple queries in o...   \n",
       "1   90  Good branching and merging tutorials for Torto...   \n",
       "2  120                                  ASP.NET Site Maps   \n",
       "3  180                 Function for creating color wheels   \n",
       "4  260  Adding scripting functionality to .NET applica...   \n",
       "\n",
       "                                                Body  \n",
       "0  I've written a database generation script in S...  \n",
       "1  Are there any really good tutorials explaining...  \n",
       "2  Has anyone got experience creating SQL-based A...  \n",
       "3  This is something I've pseudo-solved many time...  \n",
       "4  I have a little game written in C#. It uses a ...  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ques = pd.read_csv('C://Users//Kamal//Desktop//StackOverFlow-Classification-master//question_clean.csv', encoding='iso-8859-1')\n",
    "ques.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(706336, 4)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Title</th>\n",
       "      <th>Body</th>\n",
       "      <th>Tags</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>260</td>\n",
       "      <td>Adding scripting functionality to .NET applica...</td>\n",
       "      <td>I have a little game written in C#. It uses a ...</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>330</td>\n",
       "      <td>Should I use nested classes in this case?</td>\n",
       "      <td>I am working on a collection of classes used f...</td>\n",
       "      <td>[c++]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>650</td>\n",
       "      <td>Automatically update version number</td>\n",
       "      <td>I would like the version property of my applic...</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>930</td>\n",
       "      <td>How do I connect to a database and loop over a...</td>\n",
       "      <td>What's the simplest way to connect and query a...</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1010</td>\n",
       "      <td>How to get the value of built, encoded ViewState?</td>\n",
       "      <td>I need to grab the base64-encoded representati...</td>\n",
       "      <td>[c#]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Id                                              Title  \\\n",
       "0   260  Adding scripting functionality to .NET applica...   \n",
       "1   330          Should I use nested classes in this case?   \n",
       "2   650                Automatically update version number   \n",
       "3   930  How do I connect to a database and loop over a...   \n",
       "4  1010  How to get the value of built, encoded ViewState?   \n",
       "\n",
       "                                                Body   Tags  \n",
       "0  I have a little game written in C#. It uses a ...   [c#]  \n",
       "1  I am working on a collection of classes used f...  [c++]  \n",
       "2  I would like the version property of my applic...   [c#]  \n",
       "3  What's the simplest way to connect and query a...   [c#]  \n",
       "4  I need to grab the base64-encoded representati...   [c#]  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total=pd.merge(ques, top10_tags, on='Id')\n",
    "print(total.shape)\n",
    "total.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MultiLabelBinarizer\n",
    "from nltk import word_tokenize\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing import sequence\n",
    "\n",
    "\n",
    "from keras.layers import LSTM, Activation, Dense, Dropout, Input, Embedding, BatchNormalization, GRU ,concatenate\n",
    "from keras.models import Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['android', 'c#', 'c++', 'html', 'ios', 'java', 'javascript',\n",
       "       'jquery', 'php', 'python'], dtype=object)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multilabel_binarizer = MultiLabelBinarizer()\n",
    "multilabel_binarizer.fit(total.Tags)\n",
    "labels = multilabel_binarizer.classes_\n",
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "train,test=train_test_split(total[:550000],test_size=0.25,random_state=24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((412500, 4), (137500, 4))"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape,test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_t=train['Title']\n",
    "X_train_b=train['Body']\n",
    "y_train=multilabel_binarizer.transform(train['Tags'])\n",
    "X_test_t=test['Title']\n",
    "X_test_b=test['Body']\n",
    "y_test=multilabel_binarizer.transform(test['Tags'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent_lens_t=[]\n",
    "for sent in train['Title']:\n",
    "    sent_lens_t.append(len(word_tokenize(sent)))\n",
    "max(sent_lens_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.quantile(sent_lens_t,0.97)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "max_len_t = 18\n",
    "tok = Tokenizer(char_level=False,split=' ')\n",
    "tok.fit_on_texts(X_train_t)\n",
    "sequences_train_t = tok.texts_to_sequences(X_train_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68969"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vocab_len_t=len(tok.index_word.keys())\n",
    "vocab_len_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[    0,     0,     0, ...,     1,   957,   197],\n",
       "       [    0,     0,     0, ...,  9081,    45,   533],\n",
       "       [    0,     0,     0, ...,   147,     8,   230],\n",
       "       ...,\n",
       "       [    0,     0,     0, ...,    10,    71,  2985],\n",
       "       [    0,     0,     0, ...,     2,    18,    75],\n",
       "       [    0,     0,     0, ..., 11009,   809,   267]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequences_matrix_train_t = sequence.pad_sequences(sequences_train_t,maxlen=max_len_t)\n",
    "sequences_matrix_train_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequences_test_t = tok.texts_to_sequences(X_test_t)\n",
    "sequences_matrix_test_t = sequence.pad_sequences(sequences_test_t,maxlen=max_len_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((412500, 18), (137500, 18), (412500, 10), (137500, 10))"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequences_matrix_train_t.shape,sequences_matrix_test_t.shape,y_train.shape,y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sent_lens_b=[]\n",
    "for sent in train['Body']:\n",
    "    sent_lens_b.append(len(word_tokenize(sent)))\n",
    "max(sent_lens_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.quantile(sent_lens_b,0.90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_len_b = 600\n",
    "tok = Tokenizer(char_level=False,split=' ')\n",
    "tok.fit_on_texts(X_train_b)\n",
    "sequences_train_b = tok.texts_to_sequences(X_train_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1292018"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vocab_len_b =len(tok.index_word.keys())\n",
    "vocab_len_b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    0,    0, ...,   51, 2082,   91],\n",
       "       [   0,    0,    0, ..., 1408,  203,  825],\n",
       "       [   0,    0,    0, ...,   34,   51,   83],\n",
       "       ...,\n",
       "       [   0,    0,    0, ...,   20,   68,  687],\n",
       "       [   0,    0,    0, ...,  187,   58,   10],\n",
       "       [   0,    0,    0, ...,  194,  197,   10]], dtype=int32)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequences_matrix_train_b = sequence.pad_sequences(sequences_train_b,maxlen=max_len_b)\n",
    "sequences_matrix_train_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequences_test_b = tok.texts_to_sequences(X_test_b)\n",
    "sequences_matrix_test_b = sequence.pad_sequences(sequences_test_b,maxlen=max_len_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((412500, 18), (412500, 600), (412500, 10))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequences_matrix_train_t.shape,sequences_matrix_train_b.shape,y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((137500, 18), (137500, 600), (137500, 10))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequences_matrix_test_t.shape,sequences_matrix_test_b.shape,y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RNN():\n",
    "    # Title Only\n",
    "    title_input = Input(name='title_input',shape=[max_len_t])\n",
    "    title_Embed = Embedding(vocab_len_t+1,2000,input_length=max_len_t,mask_zero=True,name='title_Embed')(title_input)\n",
    "    gru_out_t = GRU(300)(title_Embed)\n",
    "    # auxiliary output to tune GRU weights smoothly \n",
    "    auxiliary_output = Dense(10, activation='sigmoid', name='aux_output')(gru_out_t)   \n",
    "    \n",
    "    # Body Only\n",
    "    body_input = Input(name='body_input',shape=[max_len_b]) \n",
    "    body_Embed = Embedding(vocab_len_b+1,170,input_length=max_len_b,mask_zero=True,name='body_Embed')(body_input)\n",
    "    gru_out_b = GRU(200)(body_Embed)\n",
    "    \n",
    "    # combined with GRU output\n",
    "    com = concatenate([gru_out_t, gru_out_b])\n",
    "    \n",
    "    # now the combined data is being fed to dense layers\n",
    "    dense1 = Dense(400,activation='relu')(com)\n",
    "    dp1 = Dropout(0.5)(dense1)\n",
    "    bn = BatchNormalization()(dp1) \n",
    "    dense2 = Dense(150,activation='relu')(bn)\n",
    "    \n",
    "    main_output = Dense(10, activation='sigmoid', name='main_output')(dense2)\n",
    "    \n",
    "    model = Model(inputs=[title_input, body_input],outputs=[main_output, auxiliary_output])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "title_input (InputLayer)        (None, 18)           0                                            \n",
      "__________________________________________________________________________________________________\n",
      "body_input (InputLayer)         (None, 600)          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "title_Embed (Embedding)         (None, 18, 2000)     137940000   title_input[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "body_Embed (Embedding)          (None, 600, 170)     219643230   body_input[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "gru_1 (GRU)                     (None, 300)          2070900     title_Embed[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "gru_2 (GRU)                     (None, 200)          222600      body_Embed[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_1 (Concatenate)     (None, 500)          0           gru_1[0][0]                      \n",
      "                                                                 gru_2[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "dense_1 (Dense)                 (None, 400)          200400      concatenate_1[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "dropout_1 (Dropout)             (None, 400)          0           dense_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "batch_normalization_1 (BatchNor (None, 400)          1600        dropout_1[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "dense_2 (Dense)                 (None, 150)          60150       batch_normalization_1[0][0]      \n",
      "__________________________________________________________________________________________________\n",
      "main_output (Dense)             (None, 10)           1510        dense_2[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "aux_output (Dense)              (None, 10)           3010        gru_1[0][0]                      \n",
      "==================================================================================================\n",
      "Total params: 360,143,400\n",
      "Trainable params: 360,142,600\n",
      "Non-trainable params: 800\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = RNN()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer='adam',loss={'main_output': 'categorical_crossentropy', 'aux_output': 'categorical_crossentropy'},\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/gradients_impl.py:107: UserWarning: Converting sparse IndexedSlices to a dense Tensor with 137940000 elements. This may consume a large amount of memory.\n",
      "  num_elements)\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/gradients_impl.py:107: UserWarning: Converting sparse IndexedSlices to a dense Tensor with 219643230 elements. This may consume a large amount of memory.\n",
      "  num_elements)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 412500 samples, validate on 137500 samples\n",
      "Epoch 1/5\n",
      "412500/412500 [==============================] - 819s 2ms/step - loss: 2.3168 - main_output_loss: 1.0405 - aux_output_loss: 1.2763 - main_output_acc: 0.7285 - aux_output_acc: 0.6705 - val_loss: 1.7714 - val_main_output_loss: 0.7258 - val_aux_output_loss: 1.0456 - val_main_output_acc: 0.8254 - val_aux_output_acc: 0.7285\n",
      "Epoch 2/5\n",
      "412500/412500 [==============================] - 797s 2ms/step - loss: 1.5874 - main_output_loss: 0.6490 - aux_output_loss: 0.9384 - main_output_acc: 0.8443 - aux_output_acc: 0.7582 - val_loss: 1.7043 - val_main_output_loss: 0.6581 - val_aux_output_loss: 1.0462 - val_main_output_acc: 0.8379 - val_aux_output_acc: 0.7286\n",
      "Epoch 3/5\n",
      "412500/412500 [==============================] - 797s 2ms/step - loss: 1.3994 - main_output_loss: 0.5472 - aux_output_loss: 0.8522 - main_output_acc: 0.8650 - aux_output_acc: 0.7774 - val_loss: 1.7369 - val_main_output_loss: 0.6660 - val_aux_output_loss: 1.0708 - val_main_output_acc: 0.8364 - val_aux_output_acc: 0.7263\n",
      "Epoch 4/5\n",
      "412500/412500 [==============================] - 798s 2ms/step - loss: 1.2719 - main_output_loss: 0.4735 - aux_output_loss: 0.7984 - main_output_acc: 0.8774 - aux_output_acc: 0.7885 - val_loss: 1.7988 - val_main_output_loss: 0.6976 - val_aux_output_loss: 1.1012 - val_main_output_acc: 0.8369 - val_aux_output_acc: 0.7240\n",
      "Epoch 5/5\n",
      "412500/412500 [==============================] - 797s 2ms/step - loss: 1.1665 - main_output_loss: 0.4110 - aux_output_loss: 0.7555 - main_output_acc: 0.8868 - aux_output_acc: 0.7976 - val_loss: 1.9099 - val_main_output_loss: 0.7671 - val_aux_output_loss: 1.1428 - val_main_output_acc: 0.8307 - val_aux_output_acc: 0.7237\n"
     ]
    }
   ],
   "source": [
    "results=model.fit({'title_input': sequences_matrix_train_t, 'body_input': sequences_matrix_train_b},\n",
    "          {'main_output': y_train, 'aux_output': y_train},\n",
    "          validation_data=[{'title_input': sequences_matrix_test_t, 'body_input': sequences_matrix_test_b},\n",
    "          {'main_output': y_test, 'aux_output': y_test}],\n",
    "          epochs=5, batch_size=800)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "137500/137500 [==============================] - 1270s 9ms/step\n"
     ]
    }
   ],
   "source": [
    "(predicted_main, predicted_aux)=model.predict({'title_input': sequences_matrix_test_t, 'body_input': sequences_matrix_test_b},verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report,f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8424636536796537\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/sklearn/metrics/classification.py:1143: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in samples with no predicted labels.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "print(f1_score(y_test,predicted_main>.55,average='samples'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.93      0.95     17054\n",
      "           1       0.92      0.84      0.88     20681\n",
      "           2       0.92      0.81      0.86      9700\n",
      "           3       0.69      0.53      0.60     11304\n",
      "           4       0.96      0.91      0.94      8897\n",
      "           5       0.91      0.80      0.85     22472\n",
      "           6       0.82      0.72      0.76     22938\n",
      "           7       0.81      0.83      0.82     16150\n",
      "           8       0.92      0.90      0.91     19659\n",
      "           9       0.97      0.92      0.95     11576\n",
      "\n",
      "   micro avg       0.89      0.82      0.85    160431\n",
      "   macro avg       0.89      0.82      0.85    160431\n",
      "weighted avg       0.89      0.82      0.85    160431\n",
      " samples avg       0.86      0.85      0.84    160431\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/sklearn/metrics/classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in samples with no predicted labels.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test,predicted_main>.55))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Id                                                16470700\n",
       "Title    NetworkOnMainThreadException- Have tried makin...\n",
       "Body     I've been trying to get this to work for a whi...\n",
       "Tags                                       [java, android]\n",
       "Name: 250148, dtype: object"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.iloc[24]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.  , 0.  , 0.  , 0.  , 0.  , 0.84, 0.  , 0.  , 0.  , 0.  ],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_main[24].round(decimals = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['android', 'c#', 'c++', 'html', 'ios', 'java', 'javascript',\n",
       "       'jquery', 'php', 'python'], dtype=object)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('./stackoverflow_tags.h5')"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}