Sentiment Analysis-CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchtext import data\n",
    "from torchtext import datasets\n",
    "import random\n",
    "import numpy as np\n",
    "\n",
    "SEED = 1234\n",
    "\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "torch.backends.cudnn.deterministic = True\n",
    "\n",
    "TEXT = data.Field(tokenize = 'spacy', batch_first = True)\n",
    "LABEL = data.LabelField(dtype = torch.float)\n",
    "\n",
    "train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)\n",
    "\n",
    "train_data, valid_data = train_data.split(random_state = random.seed(SEED))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_VOCAB_SIZE = 25_000\n",
    "\n",
    "TEXT.build_vocab(train_data, \n",
    "                 max_size = MAX_VOCAB_SIZE, \n",
    "                 vectors = \"glove.6B.100d\", \n",
    "                 unk_init = torch.Tensor.normal_)\n",
    "\n",
    "LABEL.build_vocab(train_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 64\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(\n",
    "    (train_data, valid_data, test_data), \n",
    "    batch_size = BATCH_SIZE, \n",
    "    device = device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, output_dim, \n",
    "                 dropout, pad_idx):\n",
    "        \n",
    "        super().__init__()\n",
    "        \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx = pad_idx)\n",
    "        \n",
    "        self.conv_0 = nn.Conv2d(in_channels = 1, \n",
    "                                out_channels = n_filters, \n",
    "                                kernel_size = (filter_sizes[0], embedding_dim))\n",
    "        \n",
    "        self.conv_1 = nn.Conv2d(in_channels = 1, \n",
    "                                out_channels = n_filters, \n",
    "                                kernel_size = (filter_sizes[1], embedding_dim))\n",
    "        \n",
    "        self.conv_2 = nn.Conv2d(in_channels = 1, \n",
    "                                out_channels = n_filters, \n",
    "                                kernel_size = (filter_sizes[2], embedding_dim))\n",
    "        \n",
    "        self.fc = nn.Linear(len(filter_sizes) * n_filters, output_dim)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, text):\n",
    "                \n",
    "        #text = [batch size, sent len]\n",
    "        \n",
    "        embedded = self.embedding(text)\n",
    "                \n",
    "        #embedded = [batch size, sent len, emb dim]\n",
    "        \n",
    "        embedded = embedded.unsqueeze(1)\n",
    "        \n",
    "        #embedded = [batch size, 1, sent len, emb dim]\n",
    "        \n",
    "        conved_0 = F.relu(self.conv_0(embedded).squeeze(3))\n",
    "        conved_1 = F.relu(self.conv_1(embedded).squeeze(3))\n",
    "        conved_2 = F.relu(self.conv_2(embedded).squeeze(3))\n",
    "            \n",
    "        #conved_n = [batch size, n_filters, sent len - filter_sizes[n] + 1]\n",
    "        \n",
    "        pooled_0 = F.max_pool1d(conved_0, conved_0.shape[2]).squeeze(2)\n",
    "        pooled_1 = F.max_pool1d(conved_1, conved_1.shape[2]).squeeze(2)\n",
    "        pooled_2 = F.max_pool1d(conved_2, conved_2.shape[2]).squeeze(2)\n",
    "        \n",
    "        #pooled_n = [batch size, n_filters]\n",
    "        \n",
    "        cat = self.dropout(torch.cat((pooled_0, pooled_1, pooled_2), dim = 1))\n",
    "\n",
    "        #cat = [batch size, n_filters * len(filter_sizes)]\n",
    "            \n",
    "        return self.fc(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, output_dim, \n",
    "                 dropout, pad_idx):\n",
    "        \n",
    "        super().__init__()\n",
    "                \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx = pad_idx)\n",
    "        \n",
    "        self.convs = nn.ModuleList([\n",
    "                                    nn.Conv2d(in_channels = 1, \n",
    "                                              out_channels = n_filters, \n",
    "                                              kernel_size = (fs, embedding_dim)) \n",
    "                                    for fs in filter_sizes\n",
    "                                    ])\n",
    "        \n",
    "        self.fc = nn.Linear(len(filter_sizes) * n_filters, output_dim)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, text):\n",
    "                \n",
    "        #text = [batch size, sent len]\n",
    "        \n",
    "        embedded = self.embedding(text)\n",
    "                \n",
    "        #embedded = [batch size, sent len, emb dim]\n",
    "        \n",
    "        embedded = embedded.unsqueeze(1)\n",
    "        \n",
    "        #embedded = [batch size, 1, sent len, emb dim]\n",
    "        \n",
    "        conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs]\n",
    "            \n",
    "        #conved_n = [batch size, n_filters, sent len - filter_sizes[n] + 1]\n",
    "                \n",
    "        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]\n",
    "        \n",
    "        #pooled_n = [batch size, n_filters]\n",
    "        \n",
    "        cat = self.dropout(torch.cat(pooled, dim = 1))\n",
    "\n",
    "        #cat = [batch size, n_filters * len(filter_sizes)]\n",
    "            \n",
    "        return self.fc(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN1d(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, output_dim, \n",
    "                 dropout, pad_idx):\n",
    "        \n",
    "        super().__init__()\n",
    "        \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx = pad_idx)\n",
    "        \n",
    "        self.convs = nn.ModuleList([\n",
    "                                    nn.Conv1d(in_channels = embedding_dim, \n",
    "                                              out_channels = n_filters, \n",
    "                                              kernel_size = fs)\n",
    "                                    for fs in filter_sizes\n",
    "                                    ])\n",
    "        \n",
    "        self.fc = nn.Linear(len(filter_sizes) * n_filters, output_dim)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, text):\n",
    "        \n",
    "        #text = [batch size, sent len]\n",
    "        \n",
    "        embedded = self.embedding(text)\n",
    "                \n",
    "        #embedded = [batch size, sent len, emb dim]\n",
    "        \n",
    "        embedded = embedded.permute(0, 2, 1)\n",
    "        \n",
    "        #embedded = [batch size, emb dim, sent len]\n",
    "        \n",
    "        conved = [F.relu(conv(embedded)) for conv in self.convs]\n",
    "            \n",
    "        #conved_n = [batch size, n_filters, sent len - filter_sizes[n] + 1]\n",
    "        \n",
    "        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]\n",
    "        \n",
    "        #pooled_n = [batch size, n_filters]\n",
    "        \n",
    "        cat = self.dropout(torch.cat(pooled, dim = 1))\n",
    "        \n",
    "        #cat = [batch size, n_filters * len(filter_sizes)]\n",
    "            \n",
    "        return self.fc(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_DIM = len(TEXT.vocab)\n",
    "EMBEDDING_DIM = 100\n",
    "N_FILTERS = 100\n",
    "FILTER_SIZES = [3,4,5]\n",
    "OUTPUT_DIM = 1\n",
    "DROPOUT = 0.5\n",
    "PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n",
    "\n",
    "model = CNN(INPUT_DIM, EMBEDDING_DIM, N_FILTERS, FILTER_SIZES, OUTPUT_DIM, DROPOUT, PAD_IDX)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has 2,620,801 trainable parameters\n"
     ]
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(f'The model has {count_parameters(model):,} trainable parameters')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.1117, -0.4966,  0.1631,  ...,  1.2647, -0.2753, -0.1325],\n",
       "        [-0.8555, -0.7208,  1.3755,  ...,  0.0825, -1.1314,  0.3997],\n",
       "        [-0.0382, -0.2449,  0.7281,  ..., -0.1459,  0.8278,  0.2706],\n",
       "        ...,\n",
       "        [-1.8863, -0.3506, -1.0142,  ...,  0.5013,  0.1595,  0.3652],\n",
       "        [-0.8086,  0.1864,  0.6274,  ..., -0.5705,  0.3693,  0.0856],\n",
       "        [ 0.3276,  0.0985, -0.3828,  ..., -0.3682,  0.1669, -0.1790]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pretrained_embeddings = TEXT.vocab.vectors\n",
    "\n",
    "model.embedding.weight.data.copy_(pretrained_embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "UNK_IDX = TEXT.vocab.stoi[TEXT.unk_token]\n",
    "\n",
    "model.embedding.weight.data[UNK_IDX] = torch.zeros(EMBEDDING_DIM)\n",
    "model.embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "model = model.to(device)\n",
    "criterion = criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary_accuracy(preds, y):\n",
    "    \"\"\"\n",
    "    Returns accuracy per batch, i.e. if you get 8/10 right, this returns 0.8, NOT 8\n",
    "    \"\"\"\n",
    "\n",
    "    #round predictions to the closest integer\n",
    "    rounded_preds = torch.round(torch.sigmoid(preds))\n",
    "    correct = (rounded_preds == y).float() #convert into float for division \n",
    "    acc = correct.sum() / len(correct)\n",
    "    return acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, iterator, optimizer, criterion):\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    epoch_acc = 0\n",
    "    \n",
    "    model.train()\n",
    "    \n",
    "    for batch in iterator:\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        predictions = model(batch.text).squeeze(1)\n",
    "        \n",
    "        loss = criterion(predictions, batch.label)\n",
    "        \n",
    "        acc = binary_accuracy(predictions, batch.label)\n",
    "        \n",
    "        loss.backward()\n",
    "        \n",
    "        optimizer.step()\n",
    "        \n",
    "        epoch_loss += loss.item()\n",
    "        epoch_acc += acc.item()\n",
    "        \n",
    "    return epoch_loss / len(iterator), epoch_acc / len(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, iterator, criterion):\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    epoch_acc = 0\n",
    "    \n",
    "    model.eval()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "    \n",
    "        for batch in iterator:\n",
    "\n",
    "            predictions = model(batch.text).squeeze(1)\n",
    "            \n",
    "            loss = criterion(predictions, batch.label)\n",
    "            \n",
    "            acc = binary_accuracy(predictions, batch.label)\n",
    "\n",
    "            epoch_loss += loss.item()\n",
    "            epoch_acc += acc.item()\n",
    "        \n",
    "    return epoch_loss / len(iterator), epoch_acc / len(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "def epoch_time(start_time, end_time):\n",
    "    elapsed_time = end_time - start_time\n",
    "    elapsed_mins = int(elapsed_time / 60)\n",
    "    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n",
    "    return elapsed_mins, elapsed_secs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 01 | Epoch Time: 39m 33s\n",
      "\tTrain Loss: 0.658 | Train Acc: 61.09%\n",
      "\t Val. Loss: 0.534 |  Val. Acc: 76.08%\n",
      "Epoch: 02 | Epoch Time: 45m 15s\n",
      "\tTrain Loss: 0.435 | Train Acc: 80.12%\n",
      "\t Val. Loss: 0.363 |  Val. Acc: 83.97%\n",
      "Epoch: 03 | Epoch Time: 46m 13s\n",
      "\tTrain Loss: 0.308 | Train Acc: 87.08%\n",
      "\t Val. Loss: 0.335 |  Val. Acc: 85.38%\n",
      "Epoch: 04 | Epoch Time: 45m 39s\n",
      "\tTrain Loss: 0.221 | Train Acc: 91.36%\n",
      "\t Val. Loss: 0.311 |  Val. Acc: 86.99%\n",
      "Epoch: 05 | Epoch Time: 42m 8s\n",
      "\tTrain Loss: 0.156 | Train Acc: 94.25%\n",
      "\t Val. Loss: 0.325 |  Val. Acc: 86.91%\n"
     ]
    }
   ],
   "source": [
    "N_EPOCHS = 5\n",
    "\n",
    "best_valid_loss = float('inf')\n",
    "\n",
    "for epoch in range(N_EPOCHS):\n",
    "\n",
    "    start_time = time.time()\n",
    "    \n",
    "    train_loss, train_acc = train(model, train_iterator, optimizer, criterion)\n",
    "    valid_loss, valid_acc = evaluate(model, valid_iterator, criterion)\n",
    "    \n",
    "    end_time = time.time()\n",
    "\n",
    "    epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n",
    "    \n",
    "    if valid_loss < best_valid_loss:\n",
    "        best_valid_loss = valid_loss\n",
    "        torch.save(model.state_dict(), 'tut4-model.pt')\n",
    "    \n",
    "    print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n",
    "    print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n",
    "    print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.338 | Test Acc: 85.66%\n"
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load('tut4-model.pt'))\n",
    "\n",
    "test_loss, test_acc = evaluate(model, test_iterator, criterion)\n",
    "\n",
    "print(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import spacy\n",
    "nlp = spacy.load('en')\n",
    "\n",
    "def predict_sentiment(model, sentence, min_len = 5):\n",
    "    model.eval()\n",
    "    tokenized = [tok.text for tok in nlp.tokenizer(sentence)]\n",
    "    if len(tokenized) < min_len:\n",
    "        tokenized += ['<pad>'] * (min_len - len(tokenized))\n",
    "    indexed = [TEXT.vocab.stoi[t] for t in tokenized]\n",
    "    tensor = torch.LongTensor(indexed).to(device)\n",
    "    tensor = tensor.unsqueeze(0)\n",
    "    prediction = torch.sigmoid(model(tensor))\n",
    "    return prediction.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.18350258469581604"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict_sentiment(model, \"dota2 is the worst game\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8272331953048706"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict_sentiment(model, \"i really love dota2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1441, 5)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "dota2_reviews = pd.read_csv(\"Datasets\\dota2.csv\")\n",
    "\n",
    "dota2_reviews.isnull().values.any()\n",
    "\n",
    "dota2_reviews.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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>timestamp</th>\n",
       "      <th>tweet_text</th>\n",
       "      <th>username</th>\n",
       "      <th>all_hashtags</th>\n",
       "      <th>followers_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2020-02-05 17:53:00</td>\n",
       "      <td>b\"Got 'er oiled up and loaded! https://t.co/62...</td>\n",
       "      <td>b'redditdota2'</td>\n",
       "      <td>['dota2']</td>\n",
       "      <td>65004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2020-02-05 17:42:56</td>\n",
       "      <td>b'Interview with Maxime Lebled, who did cinema...</td>\n",
       "      <td>b'redditdota2'</td>\n",
       "      <td>['dota2']</td>\n",
       "      <td>65004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2020-02-05 17:33:38</td>\n",
       "      <td>b\"So meee and my squad is gon have bet game th...</td>\n",
       "      <td>b'cymrihealyy'</td>\n",
       "      <td>['dota2']</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>2020-02-05 17:23:14</td>\n",
       "      <td>b'DOTA UnderLords deserves more love | old und...</td>\n",
       "      <td>b'MaOmega3'</td>\n",
       "      <td>['dota', 'underlods', 'underlordsnewpatch', 'd...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>2020-02-05 17:21:38</td>\n",
       "      <td>b'I just want Zeus to not have a bijillion her...</td>\n",
       "      <td>b'Mellonbug'</td>\n",
       "      <td>['dota2', 'dota', 'twitchstreamer', 'TwitchAff...</td>\n",
       "      <td>44</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             timestamp                                         tweet_text  \\\n",
       "0  2020-02-05 17:53:00  b\"Got 'er oiled up and loaded! https://t.co/62...   \n",
       "1  2020-02-05 17:42:56  b'Interview with Maxime Lebled, who did cinema...   \n",
       "2  2020-02-05 17:33:38  b\"So meee and my squad is gon have bet game th...   \n",
       "3  2020-02-05 17:23:14  b'DOTA UnderLords deserves more love | old und...   \n",
       "4  2020-02-05 17:21:38  b'I just want Zeus to not have a bijillion her...   \n",
       "\n",
       "         username                                       all_hashtags  \\\n",
       "0  b'redditdota2'                                          ['dota2']   \n",
       "1  b'redditdota2'                                          ['dota2']   \n",
       "2  b'cymrihealyy'                                          ['dota2']   \n",
       "3     b'MaOmega3'  ['dota', 'underlods', 'underlordsnewpatch', 'd...   \n",
       "4    b'Mellonbug'  ['dota2', 'dota', 'twitchstreamer', 'TwitchAff...   \n",
       "\n",
       "   followers_count  \n",
       "0            65004  \n",
       "1            65004  \n",
       "2               14  \n",
       "3                0  \n",
       "4               44  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dota2_reviews.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_text(sen):\n",
    "    # Removing html tags\n",
    "    sentence = remove_tags(sen)\n",
    "\n",
    "    # Remove punctuations and numbers\n",
    "    sentence = re.sub('[^a-zA-Z]', ' ', sentence)\n",
    "\n",
    "    # Single character removal\n",
    "    sentence = re.sub(r\"\\s+[a-zA-Z]\\s+\", ' ', sentence)\n",
    "\n",
    "    # Removing multiple spaces\n",
    "    sentence = re.sub(r'\\s+', ' ', sentence)\n",
    "\n",
    "    return sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "TAG_RE = re.compile(r'<[^>]+>')\n",
    "\n",
    "def remove_tags(text):\n",
    "    return TAG_RE.sub('', text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = []\n",
    "T = []\n",
    "A = 0\n",
    "N = 0\n",
    "P = 0\n",
    "sentences = list(dota2_reviews['tweet_text'])\n",
    "for sen in sentences:\n",
    "    T.append(preprocess_text(sen))\n",
    "    s = predict_sentiment(model, preprocess_text(sen))\n",
    "    A = A + s\n",
    "    if s<0.5:\n",
    "        N = N + 1\n",
    "    else :\n",
    "        P = P + 1\n",
    "    X.append(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.hist(X, bins = 10,color='#0504aa', alpha=0.7, rwidth=0.85)\n",
    "plt.ylabel(\"Count\")\n",
    "plt.xlabel(\"Value\")\n",
    "plt.title(\"Analisis Sentiment Dota 2\")\n",
    "plt.xticks([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])\n",
    "plt.show()\n",
    "\n",
    "labels = ['Positive', 'Negative']\n",
    "sizes = [P,N]\n",
    "colors = ['lightskyblue', 'lightcoral']\n",
    "patches, texts = plt.pie(sizes, colors=colors, shadow=True, startangle=90)\n",
    "plt.legend(patches, labels, loc=\"best\")\n",
    "plt.pie(sizes, labels=labels, colors=colors,\n",
    "autopct='%1.1f%%', shadow=True, startangle=90)\n",
    "plt.axis('equal')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}