fc-multioutput.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import platform\n",
    "import os\n",
    "import glob\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "\n",
    "from nltk.tokenize import word_tokenize\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data prep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if platform.system() == 'Linux':\n",
    "    data_path = 'data'\n",
    "else:\n",
    "    data_path = 'D:/Dataset/support-ticket-classification'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "files = glob.glob(os.path.join(data_path, '*'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data = pd.read_csv(files[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(48549, 9)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['title', 'body', 'ticket_type', 'category', 'sub_category1',\n",
       "       'sub_category2', 'business_service', 'urgency', 'impact'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4     34061\n",
       "5      9634\n",
       "6      2628\n",
       "7       921\n",
       "11      612\n",
       "8       239\n",
       "9       191\n",
       "3       137\n",
       "1        72\n",
       "12       45\n",
       "0         4\n",
       "2         3\n",
       "10        2\n",
       "Name: category, dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.category.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    34621\n",
       "0    13928\n",
       "Name: ticket_type, dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.ticket_type.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    34621\n",
       "1     6748\n",
       "2     5528\n",
       "0     1652\n",
       "Name: urgency, dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.urgency.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4    34621\n",
       "3    13184\n",
       "0      471\n",
       "2      228\n",
       "1       45\n",
       "Name: impact, dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.impact.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data.drop(d_data[d_data.category.isin([0,2,10])].index, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1        72\n",
       "3       137\n",
       "4     34061\n",
       "5      9634\n",
       "6      2628\n",
       "7       921\n",
       "8       239\n",
       "9       191\n",
       "11      612\n",
       "12       45\n",
       "Name: category, dtype: int64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.category.value_counts().sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "cat2new = dict((index, value) for index, value in enumerate(d_data.category.value_counts().sort_index().index))\n",
    "new2cat = dict((value, index) for index, value in enumerate(d_data.category.value_counts().sort_index().index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data['category'] = d_data.category.map(new2cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## value encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fill na in title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data.title = d_data.title.fillna('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "title               0\n",
       "body                0\n",
       "ticket_type         0\n",
       "category            0\n",
       "sub_category1       0\n",
       "sub_category2       0\n",
       "business_service    0\n",
       "urgency             0\n",
       "impact              0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_data.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data['title_body'] = d_data['title'] + d_data['body']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data.title_body = d_data.title_body.str.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \" \".join(list(d_data.title_body))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_set = set(word_tokenize(text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx2word = dict((index, word) for index, word in enumerate(word_set, 1))\n",
    "word2idx = dict((word, index) for index, word in enumerate(word_set, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def word_encoding(sentence, encoding):\n",
    "    word_list = word_tokenize(sentence)\n",
    "    sent2idx = []\n",
    "    for word in word_list:\n",
    "        try:\n",
    "            sent2idx.append(encoding[word])\n",
    "        except:\n",
    "            sent2idx.append(0)\n",
    "            \n",
    "    return sent2idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22093"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word2idx['hi']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data = d_data.sample(frac=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data_selected = d_data[['title_body', 'category', 'ticket_type', 'urgency', 'impact']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_data_selected.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "row, col = d_data_selected.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "train, test = d_data_selected.iloc[:int(row * 0.8)], d_data_selected.iloc[int(row * 0.8):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(38832, 5)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9708, 5)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_label = ['category', 'ticket_type', 'urgency', 'impact']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "category\n",
      "0       54\n",
      "1      117\n",
      "2    27252\n",
      "3     7662\n",
      "4     2136\n",
      "5      749\n",
      "6      192\n",
      "7      149\n",
      "8      486\n",
      "9       35\n",
      "Name: category, dtype: int64\n",
      "\n",
      "\n",
      "ticket_type\n",
      "0    11149\n",
      "1    27683\n",
      "Name: ticket_type, dtype: int64\n",
      "\n",
      "\n",
      "urgency\n",
      "0     1336\n",
      "1     5389\n",
      "2     4424\n",
      "3    27683\n",
      "Name: urgency, dtype: int64\n",
      "\n",
      "\n",
      "impact\n",
      "0      377\n",
      "1       38\n",
      "2      191\n",
      "3    10543\n",
      "4    27683\n",
      "Name: impact, dtype: int64\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for col in col_label:\n",
    "    print(col)\n",
    "    print(train[col].value_counts().sort_index())\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "category\n",
      "0      18\n",
      "1      20\n",
      "2    6809\n",
      "3    1972\n",
      "4     492\n",
      "5     172\n",
      "6      47\n",
      "7      42\n",
      "8     126\n",
      "9      10\n",
      "Name: category, dtype: int64\n",
      "\n",
      "\n",
      "ticket_type\n",
      "0    2776\n",
      "1    6932\n",
      "Name: ticket_type, dtype: int64\n",
      "\n",
      "\n",
      "urgency\n",
      "0     315\n",
      "1    1357\n",
      "2    1104\n",
      "3    6932\n",
      "Name: urgency, dtype: int64\n",
      "\n",
      "\n",
      "impact\n",
      "0      94\n",
      "1       7\n",
      "2      37\n",
      "3    2638\n",
      "4    6932\n",
      "Name: impact, dtype: int64\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for col in col_label:\n",
    "    print(col)\n",
    "    print(test[col].value_counts().sort_index())\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# len_sent = train.title_body.apply(word_tokenize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sns.distplot(len_sent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset():\n",
    "    def __init__(self, word2idx):\n",
    "        self.lookup = {\n",
    "            'train': (train, len(train)),\n",
    "            'test': (test, len(test))\n",
    "        }\n",
    "        \n",
    "        self.set_split('train')\n",
    "    \n",
    "    def set_split(self, split = 'train'):\n",
    "        self.data, self.length = self.lookup[split]\n",
    "        \n",
    "    def set_length_pad(self, x):\n",
    "        if len(x) > 200:\n",
    "            x = x[:200]\n",
    "        else:\n",
    "            len_pad = 200 - len(x)\n",
    "            pad = [0] * len_pad\n",
    "            x.extend(pad)\n",
    "            \n",
    "        return x\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        x = self.data.iloc[index, 0]\n",
    "        x = word_encoding(x, word2idx)\n",
    "        x = self.set_length_pad(x)\n",
    "        x = torch.Tensor(x)\n",
    "        \n",
    "        category = self.data.iloc[index, 1]\n",
    "        ticket_type = self.data.iloc[index, 2]\n",
    "        urgency = self.data.iloc[index, 3]\n",
    "        impact = self.data.iloc[index, 4]\n",
    "        \n",
    "        return {\n",
    "            'x': x,\n",
    "            'category': category,\n",
    "            'ticket': ticket_type,\n",
    "            'urgency': urgency,\n",
    "            'impact': impact\n",
    "        }\n",
    "        \n",
    "        \n",
    "    def __len__(self):\n",
    "\n",
    "        return self.length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Classifier(nn.Module):\n",
    "    def __init__(self, len_category, len_ticket_type, len_urgency, len_impact):\n",
    "        super(Classifier, self).__init__()\n",
    "        self.fc1 = nn.Linear(200, 300)\n",
    "        \n",
    "        self.fc2_1 = nn.Linear(300, 1024)\n",
    "        self.fc2_2 = nn.Linear(300, 1024)\n",
    "        self.fc2_3 = nn.Linear(300, 1024)\n",
    "        self.fc2_4 = nn.Linear(300, 1024)\n",
    "        \n",
    "        self.fc3_1 = nn.Linear(1024, 2048)\n",
    "        self.fc3_2 = nn.Linear(1024, 2048)\n",
    "        self.fc3_3 = nn.Linear(1024, 2048)\n",
    "        self.fc3_4 = nn.Linear(1024, 2048)\n",
    "        \n",
    "        self.fc4_1 = nn.Linear(2048, 2048)\n",
    "        self.fc4_2 = nn.Linear(2048, 2048)\n",
    "        self.fc4_3 = nn.Linear(2048, 2048)\n",
    "        self.fc4_4 = nn.Linear(2048, 2048)\n",
    "        \n",
    "        self.fc5_1 = nn.Linear(2048, 2048)\n",
    "        self.fc5_2 = nn.Linear(2048, 2048)\n",
    "        self.fc5_3 = nn.Linear(2048, 2048)\n",
    "        self.fc5_4 = nn.Linear(2048, 2048)\n",
    "        \n",
    "        self.fc6_1 = nn.Linear(2048, 1024)\n",
    "        self.fc6_2 = nn.Linear(2048, 1024)\n",
    "        self.fc6_3 = nn.Linear(2048, 1024)\n",
    "        self.fc6_4 = nn.Linear(2048, 1024)\n",
    "        \n",
    "        self.fc7_1 = nn.Linear(1024, 512)\n",
    "        self.fc7_2 = nn.Linear(1024, 512)\n",
    "        self.fc7_3 = nn.Linear(1024, 512)\n",
    "        self.fc7_4 = nn.Linear(1024, 512)\n",
    "        \n",
    "        self.fc8_1 = nn.Linear(512, 100)\n",
    "        self.fc8_2 = nn.Linear(512, 100)\n",
    "        self.fc8_3 = nn.Linear(512, 100)\n",
    "        self.fc8_4 = nn.Linear(512, 100)\n",
    "        \n",
    "        self.category = nn.Linear(100, len_category)\n",
    "        self.ticket_type = nn.Linear(100, len_ticket_type)\n",
    "        self.urgency = nn.Linear(100, len_urgency)\n",
    "        self.impact = nn.Linear(100, len_impact)\n",
    "        \n",
    "        \n",
    "    def forward(self, input_, apply_softmax = False):\n",
    "        x = self.fc1(input_)\n",
    "        \n",
    "        y_category = F.dropout(self.fc2_1(x), p=0.3)\n",
    "        y_category = self.fc3_1(y_category)\n",
    "        y_category = self.fc4_1(y_category)\n",
    "        y_category = self.fc5_1(y_category)\n",
    "        y_category = self.fc6_1(y_category)\n",
    "        y_category = self.fc7_1(y_category)\n",
    "        y_category = self.fc8_1(y_category)\n",
    "        y_category = self.category(y_category)\n",
    "        \n",
    "        y_ticket = F.dropout(self.fc2_2(x), p=0.3)\n",
    "        y_ticket = self.fc3_2(y_ticket)\n",
    "        y_ticket = self.fc4_2(y_ticket)\n",
    "        y_ticket = self.fc5_2(y_ticket)\n",
    "        y_ticket = self.fc6_2(y_ticket)\n",
    "        y_ticket = self.fc7_2(y_ticket)\n",
    "        y_ticket = self.fc8_2(y_ticket)\n",
    "        y_ticket = self.ticket_type(y_ticket)\n",
    "        \n",
    "        y_urgency = F.dropout(self.fc2_3(x), p=0.3)\n",
    "        y_urgency = self.fc3_3(y_urgency)\n",
    "        y_urgency = self.fc4_3(y_urgency)\n",
    "        y_urgency = self.fc5_3(y_urgency)\n",
    "        y_urgency = self.fc6_3(y_urgency)\n",
    "        y_urgency = self.fc7_3(y_urgency)\n",
    "        y_urgency = self.fc8_3(y_urgency)\n",
    "        y_urgency = self.urgency(y_urgency)\n",
    "        \n",
    "        \n",
    "        y_impact = F.dropout(self.fc2_4(x), p=0.3)\n",
    "        y_impact = self.fc3_4(y_impact)\n",
    "        y_impact = self.fc4_4(y_impact)\n",
    "        y_impact = self.fc5_4(y_impact)\n",
    "        y_impact = self.fc6_4(y_impact)\n",
    "        y_impact = self.fc7_4(y_impact)\n",
    "        y_impact = self.fc8_4(y_impact)\n",
    "        y_impact = self.impact(y_impact)\n",
    "        \n",
    "        if apply_softmax:\n",
    "            y_category = F.softmax(y_category)\n",
    "            y_ticket = F.softmax(y_ticket)\n",
    "            y_urgency = F.softmax(y_urgency)\n",
    "            y_impact = F.softmax(y_impact)\n",
    "            \n",
    "        return {'category': y_category,\n",
    "               'ticket': y_ticket,\n",
    "               'urgency': y_urgency,\n",
    "               'impact': y_impact}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_accuracy(y_pred, y_true):\n",
    "    y_pred = y_pred.max(dim=1)[1]\n",
    "    n_correct = torch.eq(y_pred, y_true).sum().item()\n",
    "    accuracy = (n_correct / len(y_true)) * 100\n",
    "    \n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = Dataset(word2idx)\n",
    "classifier = Classifier(10, 2, 4, 5)\n",
    "\n",
    "classifier = classifier.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fun_category = nn.CrossEntropyLoss()\n",
    "loss_fun_ticket = nn.CrossEntropyLoss()\n",
    "loss_fun_urgency = nn.CrossEntropyLoss()\n",
    "loss_fun_impact = nn.CrossEntropyLoss()\n",
    "\n",
    "optimizer = optim.Adam(classifier.parameters(), lr = 1e-3, weight_decay=0.0001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "running_acc = 0\n",
    "running_loss = 0\n",
    "\n",
    "running_acc_val = 0\n",
    "running_acc_cat_val = 0\n",
    "running_acc_ticket_val = 0\n",
    "running_acc_urgency_val = 0\n",
    "running_acc_impact_val = 0\n",
    "\n",
    "running_loss_val = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "history_dict = {\n",
    "    'loss_train': [],\n",
    "    'acc_train': [],\n",
    "    'loss_val': [],\n",
    "    'acc_val': [],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 0/100 loss: 4306.88 accuracy: 38.46 loss_val: 1061.86 accuracy_val: 42.51 \n",
      "           [cat:10.19 ticket:37.00 urgency: 59.67 impact: 63.17]\n",
      "epoch 1/100 loss: 762.35 accuracy: 53.46 loss_val: 266.15 accuracy_val: 53.15 \n",
      "           [cat:43.63 ticket:56.59 urgency: 54.97 impact: 57.42]\n",
      "epoch 2/100 loss: 118.45 accuracy: 52.85 loss_val: 49.46 accuracy_val: 55.99 \n",
      "           [cat:44.69 ticket:58.83 urgency: 55.19 impact: 65.26]\n",
      "epoch 3/100 loss: 28.02 accuracy: 55.86 loss_val: 19.62 accuracy_val: 56.68 \n",
      "           [cat:41.77 ticket:64.60 urgency: 51.39 impact: 68.96]\n",
      "epoch 4/100 loss: 13.17 accuracy: 56.45 loss_val: 10.32 accuracy_val: 50.84 \n",
      "           [cat:37.27 ticket:44.91 urgency: 55.10 impact: 66.09]\n",
      "epoch 5/100 loss: 7.27 accuracy: 57.13 loss_val: 4.90 accuracy_val: 60.97 \n",
      "           [cat:56.85 ticket:67.77 urgency: 53.39 impact: 65.87]\n",
      "epoch 6/100 loss: 3.57 accuracy: 58.93 loss_val: 2.76 accuracy_val: 59.71 \n",
      "           [cat:51.38 ticket:68.65 urgency: 55.71 impact: 63.12]\n",
      "epoch 7/100 loss: 2.66 accuracy: 59.87 loss_val: 2.51 accuracy_val: 58.85 \n",
      "           [cat:43.08 ticket:63.35 urgency: 64.00 impact: 64.97]\n",
      "epoch 8/100 loss: 2.48 accuracy: 60.99 loss_val: 2.92 accuracy_val: 59.07 \n",
      "           [cat:56.76 ticket:67.47 urgency: 62.92 impact: 49.14]\n",
      "epoch 9/100 loss: 2.38 accuracy: 61.76 loss_val: 1.89 accuracy_val: 63.33 \n",
      "           [cat:57.01 ticket:66.48 urgency: 64.72 impact: 65.10]\n",
      "epoch 10/100 loss: 1.77 accuracy: 62.64 loss_val: 1.58 accuracy_val: 64.98 \n",
      "           [cat:65.78 ticket:66.40 urgency: 66.19 impact: 61.56]\n",
      "epoch 11/100 loss: 1.61 accuracy: 63.60 loss_val: 1.58 accuracy_val: 63.44 \n",
      "           [cat:63.12 ticket:69.26 urgency: 65.02 impact: 56.34]\n",
      "epoch 12/100 loss: 1.64 accuracy: 63.37 loss_val: 1.68 accuracy_val: 60.51 \n",
      "           [cat:53.96 ticket:68.72 urgency: 66.08 impact: 53.27]\n",
      "epoch 13/100 loss: 1.60 accuracy: 63.79 loss_val: 1.46 accuracy_val: 64.65 \n",
      "           [cat:56.00 ticket:69.24 urgency: 65.38 impact: 67.98]\n",
      "epoch 14/100 loss: 1.48 accuracy: 65.12 loss_val: 1.44 accuracy_val: 63.76 \n",
      "           [cat:56.49 ticket:69.72 urgency: 64.26 impact: 64.57]\n",
      "epoch 15/100 loss: 1.56 accuracy: 64.37 loss_val: 1.78 accuracy_val: 63.11 \n",
      "           [cat:56.19 ticket:68.31 urgency: 65.62 impact: 62.32]\n",
      "epoch 16/100 loss: 1.51 accuracy: 64.47 loss_val: 1.53 accuracy_val: 63.64 \n",
      "           [cat:62.91 ticket:69.74 urgency: 63.64 impact: 58.25]\n",
      "epoch 17/100 loss: 1.41 accuracy: 65.80 loss_val: 1.46 accuracy_val: 66.16 \n",
      "           [cat:63.32 ticket:69.52 urgency: 67.79 impact: 64.02]\n",
      "epoch 18/100 loss: 1.36 accuracy: 65.87 loss_val: 1.35 accuracy_val: 67.18 \n",
      "           [cat:65.44 ticket:67.85 urgency: 67.62 impact: 67.82]\n",
      "epoch 19/100 loss: 1.33 accuracy: 65.56 loss_val: 1.35 accuracy_val: 64.93 \n",
      "           [cat:60.09 ticket:68.88 urgency: 67.39 impact: 63.36]\n",
      "epoch 20/100 loss: 1.27 accuracy: 65.31 loss_val: 1.24 accuracy_val: 66.44 \n",
      "           [cat:62.89 ticket:70.85 urgency: 66.42 impact: 65.60]\n",
      "epoch 21/100 loss: 1.19 accuracy: 66.37 loss_val: 1.13 accuracy_val: 67.62 \n",
      "           [cat:63.59 ticket:70.20 urgency: 67.81 impact: 68.86]\n",
      "epoch 22/100 loss: 1.17 accuracy: 66.21 loss_val: 1.21 accuracy_val: 64.76 \n",
      "           [cat:61.01 ticket:69.01 urgency: 65.88 impact: 63.12]\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(100):\n",
    "    dataset.set_split('train')\n",
    "    data_gen = DataLoader(dataset=dataset, shuffle=True, batch_size=2048)\n",
    "    classifier.train()\n",
    "    for batch_index, batch_dict in enumerate(data_gen , 1):\n",
    "        # step 1\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # step 2\n",
    "        y_pred = classifier(batch_dict['x'].to(device))\n",
    "        \n",
    "        # step 3 loss\n",
    "        loss_category = loss_fun_category(y_pred['category'], batch_dict['category'].to(device))\n",
    "        loss_ticket = loss_fun_category(y_pred['ticket'], batch_dict['ticket'].to(device))\n",
    "        loss_urgency = loss_fun_category(y_pred['urgency'], batch_dict['urgency'].to(device))\n",
    "        loss_impact = loss_fun_category(y_pred['impact'], batch_dict['impact'].to(device))\n",
    "        \n",
    "        loss = loss_category + loss_ticket + loss_urgency + loss_impact\n",
    "        running_loss += ((loss.item() / 4) - running_loss) / batch_index\n",
    "        \n",
    "        # step 4 accuracy\n",
    "        acc_category = compute_accuracy(y_pred['category'], batch_dict['category'].to(device))\n",
    "        acc_ticket = compute_accuracy(y_pred['ticket'], batch_dict['ticket'].to(device))\n",
    "        acc_urgency = compute_accuracy(y_pred['urgency'], batch_dict['urgency'].to(device))\n",
    "        acc_impact = compute_accuracy(y_pred['impact'], batch_dict['impact'].to(device))\n",
    "        \n",
    "        accuracy = (acc_category + acc_ticket + acc_urgency + acc_impact) / 4\n",
    "        running_acc += (accuracy - running_acc) / batch_index\n",
    "        \n",
    "        # step 6 backward\n",
    "        loss.backward()\n",
    "        \n",
    "        # step 6 step\n",
    "        optimizer.step()\n",
    "    \n",
    "    dataset.set_split('test')\n",
    "    data_gen = DataLoader(dataset=dataset, shuffle=True, batch_size=2048)\n",
    "    classifier.eval()\n",
    "    for batch_index, batch_dict in enumerate(data_gen , 1):\n",
    "        # step 1\n",
    "        y_pred = classifier(batch_dict['x'].to(device))\n",
    "        \n",
    "        # step 2\n",
    "        # step 3 loss\n",
    "        loss_category_val = loss_fun_category(y_pred['category'], batch_dict['category'].to(device))\n",
    "        loss_ticket_val = loss_fun_category(y_pred['ticket'], batch_dict['ticket'].to(device))\n",
    "        loss_urgency_val = loss_fun_category(y_pred['urgency'], batch_dict['urgency'].to(device))\n",
    "        loss_impact_val = loss_fun_category(y_pred['impact'], batch_dict['impact'].to(device))\n",
    "        \n",
    "        loss_val = loss_category_val + loss_ticket_val + loss_urgency_val + loss_impact_val\n",
    "        running_loss_val += ((loss_val.item() / 4) - running_loss_val) / batch_index\n",
    "        \n",
    "        # step 3\n",
    "        acc_category_val = compute_accuracy(y_pred['category'], batch_dict['category'].to(device))\n",
    "        acc_ticket_val = compute_accuracy(y_pred['ticket'], batch_dict['ticket'].to(device))\n",
    "        acc_urgency_val = compute_accuracy(y_pred['urgency'], batch_dict['urgency'].to(device))\n",
    "        acc_impact_val = compute_accuracy(y_pred['impact'], batch_dict['impact'].to(device))\n",
    "        \n",
    "        accuracy_val = (acc_category_val + acc_ticket_val + acc_urgency_val + acc_impact_val) / 4\n",
    "        running_acc_val += (accuracy_val - running_acc_val) / batch_index\n",
    "        \n",
    "        running_acc_cat_val += (acc_category_val - running_acc_cat_val) / batch_index\n",
    "        running_acc_ticket_val += (acc_ticket_val - running_acc_ticket_val) / batch_index\n",
    "        running_acc_urgency_val += (acc_urgency_val - running_acc_urgency_val) / batch_index\n",
    "        running_acc_impact_val += (acc_impact_val - running_acc_impact_val) / batch_index\n",
    "    \n",
    "    print(\"epoch {}/{} loss: {:.2f} accuracy: {:.2f} loss_val: {:.2f} accuracy_val: {:.2f} \\n \\\n",
    "          [cat:{:.2f} ticket:{:.2f} urgency: {:.2f} impact: {:.2f}]\". format(\n",
    "        epoch, 100, running_loss, running_acc, running_loss_val, running_acc_val,\n",
    "        running_acc_cat_val, running_acc_ticket_val, running_acc_urgency_val, running_acc_impact_val\n",
    "    ))\n",
    "    history_dict['loss_train'].append(running_loss)\n",
    "    history_dict['acc_train'].append(running_acc)\n",
    "    history_dict['loss_val'].append(running_loss_val)\n",
    "    history_dict['acc_val'].append(running_acc_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}