comment_evaluation_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:03.482073Z",
     "start_time": "2019-10-02T23:52:01.965000Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torchtext.data import Field, TabularDataset, Iterator\n",
    "from eunjeon import Mecab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:03.489923Z",
     "start_time": "2019-10-02T23:52:03.484927Z"
    }
   },
   "outputs": [],
   "source": [
    "# using Mecab as Tokenizer\n",
    "tokenizer = Mecab() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:03.503878Z",
     "start_time": "2019-10-02T23:52:03.493910Z"
    }
   },
   "outputs": [],
   "source": [
    "# defining the Field\n",
    "TEXT = Field(sequential=True,\n",
    "             use_vocab=True,\n",
    "             tokenize=tokenizer.morphs,  \n",
    "             lower=True, \n",
    "             batch_first=True)  \n",
    "LABEL = Field(sequential=False,  \n",
    "              use_vocab=False,   \n",
    "              preprocessing = lambda x: int(x),\n",
    "              batch_first=True, \n",
    "              is_target=True)\n",
    "ID = Field(sequential=False,  \n",
    "           use_vocab=False,   \n",
    "           is_target=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:23.597025Z",
     "start_time": "2019-10-02T23:52:03.505873Z"
    }
   },
   "outputs": [],
   "source": [
    "# divide train_data and test_data by using TabularDataset.splits function\n",
    "train_data, test_data = TabularDataset.splits(\n",
    "    path='./data', format='tsv', \n",
    "    train=\"ratings_train.txt\",\n",
    "    test=\"ratings_test.txt\",\n",
    "    fields=[('id', ID), ('text', TEXT), ('label', LABEL)],\n",
    "    skip_header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:24.587365Z",
     "start_time": "2019-10-02T23:52:23.598903Z"
    }
   },
   "outputs": [],
   "source": [
    "# making Vocabulary\n",
    "TEXT.build_vocab(train_data, min_freq=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:24.603210Z",
     "start_time": "2019-10-02T23:52:24.588251Z"
    }
   },
   "outputs": [],
   "source": [
    "# makeing model by using LSTM\n",
    "class SentimentCls(nn.Module):\n",
    "    def __init__(self, vocab_size, embed_size, hidden_size, output_size,\n",
    "                 num_layers=3, batch_first=True, bidirec=True, dropout=0.5):\n",
    "        super(SentimentCls, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.n_layers = num_layers\n",
    "        self.n_direct = 2 if bidirec else 1\n",
    "        self.embedding_layer = nn.Embedding(vocab_size, embed_size)\n",
    "        self.rnn_layer = nn.LSTM(input_size=embed_size,\n",
    "                                 hidden_size=hidden_size,\n",
    "                                 num_layers=num_layers,\n",
    "                                 batch_first=batch_first,\n",
    "                                 bidirectional=bidirec,\n",
    "                                 dropout=0.5)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.linear = nn.Linear(self.n_direct*hidden_size, output_size)\n",
    "        \n",
    "\n",
    "    def forward(self, x):\n",
    "        embeded = self.dropout(self.embedding_layer(x))\n",
    "        hidden, cell = self.init_hiddens(x.size(0), self.hidden_size, device=x.device)\n",
    "        output, (hidden, cell) = self.rnn_layer(embeded, (hidden, cell))\n",
    "        last_hidden = torch.cat([h for h in hidden[-self.n_direct:]], dim=1)\n",
    "        scores = self.linear(last_hidden)\n",
    "        return scores.view(-1)\n",
    "    \n",
    "    def init_hiddens(self, batch_size, hidden_size, device):\n",
    "        hidden = torch.zeros(self.n_direct*self.n_layers, batch_size, hidden_size)\n",
    "        cell = torch.zeros(self.n_direct*self.n_layers, batch_size, hidden_size)\n",
    "        return hidden.to(device), cell.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:25.111276Z",
     "start_time": "2019-10-02T23:52:24.607211Z"
    }
   },
   "outputs": [],
   "source": [
    "# setting arguments for model\n",
    "vocab_size = len(TEXT.vocab)  # the size of vocabulary\n",
    "embed_size = 128  # the size of embedding\n",
    "hidden_size = 256  # the size of hidden layer\n",
    "output_size = 1  # the size of output layer\n",
    "num_layers = 3  # the number of RNN layer\n",
    "batch_first = True  # if RNN's frist dim of input is the size of minibatch\n",
    "bidirec = True  # BERT\n",
    "dropdout = 0.5\n",
    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'  # device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:28.494103Z",
     "start_time": "2019-10-02T23:52:25.114268Z"
    }
   },
   "outputs": [],
   "source": [
    "# model\n",
    "model = SentimentCls(vocab_size, embed_size, hidden_size, output_size,\n",
    "                     num_layers, batch_first, bidirec, dropdout).to(DEVICE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:28.538994Z",
     "start_time": "2019-10-02T23:52:28.495098Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Load Complete!\n"
     ]
    }
   ],
   "source": [
    "# loading model\n",
    "model.load_state_dict(torch.load(\"./movie-review-model.pt\"))\n",
    "print(\"Load Complete!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:52:28.548939Z",
     "start_time": "2019-10-02T23:52:28.540960Z"
    }
   },
   "outputs": [],
   "source": [
    "# test\n",
    "def test_input(model, field, tokenizer, device):\n",
    "    sentence = input(\"Enter your sentence for test: \")\n",
    "    x = field.process([tokenizer.morphs(sentence)]).to(device)\n",
    "    output = model(x)\n",
    "    pred = torch.sigmoid(output).ge(0.5).item()\n",
    "    print(\"--- Result ---\")\n",
    "    if pred == 1:\n",
    "        print(\"Positive\")\n",
    "    else:\n",
    "        print(\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-02T23:53:47.888939Z",
     "start_time": "2019-10-02T23:53:37.480527Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your sentence for test: 이 영화 진짜 재밌어요 ㅋㅋㅋ\n",
      "--- Result ---\n",
      "Positive\n"
     ]
    }
   ],
   "source": [
    "test_input(model, field=TEXT, tokenizer=tokenizer, device=DEVICE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}