Neural_network_to_classify_texts.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from collections import Counter\n",
    "from sklearn.datasets import fetch_20newsgroups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 2\n",
      " 4\n",
      " 7\n",
      "[torch.IntTensor of size 3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = torch.IntTensor([1,3,6]) \n",
    "y = torch.IntTensor([1,1,1])\n",
    "result = x + y\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total texts in train: 1774\n",
      "total texts in test: 1180\n"
     ]
    }
   ],
   "source": [
    "categories = [\"comp.graphics\",\"sci.space\",\"rec.sport.baseball\"]\n",
    "newsgroups_train = fetch_20newsgroups(subset='train', categories=categories)\n",
    "newsgroups_test = fetch_20newsgroups(subset='test', categories=categories)\n",
    "\n",
    "print('total texts in train:',len(newsgroups_train.data))\n",
    "print('total texts in test:',len(newsgroups_test.data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "vocab = Counter()\n",
    "\n",
    "for text in newsgroups_train.data:\n",
    "    for word in text.split(' '):\n",
    "        vocab[word.lower()]+=1\n",
    "        \n",
    "for text in newsgroups_test.data:\n",
    "    for word in text.split(' '):\n",
    "        vocab[word.lower()]+=1\n",
    "        \n",
    "total_words = len(vocab)\n",
    "\n",
    "def get_word_2_index(vocab):\n",
    "    word2index = {}\n",
    "    for i,word in enumerate(vocab):\n",
    "        word2index[word.lower()] = i\n",
    "        \n",
    "    return word2index\n",
    "\n",
    "word2index = get_word_2_index(vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_batch(df,i,batch_size):\n",
    "    batches = []\n",
    "    results = []\n",
    "    texts = df.data[i*batch_size:i*batch_size+batch_size]\n",
    "    categories = df.target[i*batch_size:i*batch_size+batch_size]\n",
    "    for text in texts:\n",
    "        layer = np.zeros(total_words,dtype=float)\n",
    "        for word in text.split(' '):\n",
    "            layer[word2index[word.lower()]] += 1\n",
    "            \n",
    "        batches.append(layer)\n",
    "        \n",
    "    for category in categories:\n",
    "        index_y = -1\n",
    "        if category == 0:\n",
    "            index_y = 0\n",
    "        elif category == 1:\n",
    "            index_y = 1\n",
    "        else:\n",
    "            index_y = 2\n",
    "        results.append(index_y)\n",
    "            \n",
    "     \n",
    "    return np.array(batches),np.array(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Parameters\n",
    "learning_rate = 0.01\n",
    "num_epochs = 10\n",
    "batch_size = 150\n",
    "display_step = 1\n",
    "\n",
    "# Network Parameters\n",
    "hidden_size = 100      # 1st layer and 2nd layer number of features\n",
    "input_size = total_words # Words in vocab\n",
    "num_classes = 3         # Categories: graphics, sci.space and baseball"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class OurNet(nn.Module):\n",
    "     def __init__(self, input_size, hidden_size, num_classes):\n",
    "        super(OurNet, self).__init__()\n",
    "        self.layer_1 = nn.Linear(input_size,hidden_size, bias=True)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.layer_2 = nn.Linear(hidden_size, hidden_size, bias=True)\n",
    "        self.output_layer = nn.Linear(hidden_size, num_classes, bias=True)\n",
    " \n",
    "     def forward(self, x):\n",
    "        out = self.layer_1(x)\n",
    "        out = self.relu(out)\n",
    "        out = self.layer_2(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.output_layer(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> batch of size 2 and 5 possible classes\n",
      "Variable containing:\n",
      " 0.3048 -0.3044  1.1260 -1.0208 -0.1514\n",
      " 0.0144  1.1776  0.9862  1.2988  0.2670\n",
      "[torch.FloatTensor of size 2x5]\n",
      "\n",
      ">>> array of size 'batch_size' with the index of the maxium label for each item\n",
      "Variable containing:\n",
      " 3\n",
      " 0\n",
      "[torch.LongTensor of size 2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# input [batch_size, n_labels]\n",
    "# output [max index for each item in batch, ... ,batch_size-1]\n",
    "loss = nn.CrossEntropyLoss()\n",
    "input = Variable(torch.randn(2, 5), requires_grad=True)\n",
    "print(\">>> batch of size 2 and 5 possible classes\")\n",
    "print(input)\n",
    "target = Variable(torch.LongTensor(2).random_(5))\n",
    "print(\">>> array of size 'batch_size' with the index of the maxium label for each item\")\n",
    "print(target)\n",
    "output = loss(input, target)\n",
    "output.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/10], Step [4/11], Loss: 0.7982\n",
      "Epoch [1/10], Step [8/11], Loss: 0.4047\n",
      "Epoch [2/10], Step [4/11], Loss: 0.0213\n",
      "Epoch [2/10], Step [8/11], Loss: 0.0048\n",
      "Epoch [3/10], Step [4/11], Loss: 0.1045\n",
      "Epoch [3/10], Step [8/11], Loss: 0.3725\n",
      "Epoch [4/10], Step [4/11], Loss: 0.0000\n",
      "Epoch [4/10], Step [8/11], Loss: 0.0000\n",
      "Epoch [5/10], Step [4/11], Loss: 0.0000\n",
      "Epoch [5/10], Step [8/11], Loss: 0.0000\n",
      "Epoch [6/10], Step [4/11], Loss: 0.0000\n",
      "Epoch [6/10], Step [8/11], Loss: 0.0000\n",
      "Epoch [7/10], Step [4/11], Loss: 0.0000\n",
      "Epoch [7/10], Step [8/11], Loss: 0.0000\n",
      "Epoch [8/10], Step [4/11], Loss: 0.0011\n",
      "Epoch [8/10], Step [8/11], Loss: 0.0000\n",
      "Epoch [9/10], Step [4/11], Loss: 0.0371\n",
      "Epoch [9/10], Step [8/11], Loss: 0.0005\n",
      "Epoch [10/10], Step [4/11], Loss: 0.0001\n",
      "Epoch [10/10], Step [8/11], Loss: 0.1700\n"
     ]
    }
   ],
   "source": [
    "net = OurNet(input_size, hidden_size, num_classes)\n",
    "\n",
    "# Loss and Optimizer\n",
    "criterion = nn.CrossEntropyLoss()  \n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)  \n",
    "\n",
    "# Train the Model\n",
    "for epoch in range(num_epochs):\n",
    "    total_batch = int(len(newsgroups_train.data)/batch_size)\n",
    "    # Loop over all batches\n",
    "    for i in range(total_batch):\n",
    "        batch_x,batch_y = get_batch(newsgroups_train,i,batch_size)\n",
    "        articles = Variable(torch.FloatTensor(batch_x))\n",
    "        labels = Variable(torch.LongTensor(batch_y))\n",
    "        #print(\"articles\",articles)\n",
    "        #print(batch_x, labels)\n",
    "        #print(\"size labels\",labels.size())\n",
    "        \n",
    "        # Forward + Backward + Optimize\n",
    "        optimizer.zero_grad()  # zero the gradient buffer\n",
    "        outputs = net(articles)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        if (i+1) % 4 == 0:\n",
    "            print ('Epoch [%d/%d], Step [%d/%d], Loss: %.4f' \n",
    "                   %(epoch+1, num_epochs, i+1, len(newsgroups_train.data)//batch_size, loss.data[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 1180 test articles: 91 %\n"
     ]
    }
   ],
   "source": [
    "# Test the Model\n",
    "correct = 0\n",
    "total = 0\n",
    "total_test_data = len(newsgroups_test.target)\n",
    "batch_x_test,batch_y_test = get_batch(newsgroups_test,0,total_test_data)\n",
    "articles = Variable(torch.FloatTensor(batch_x_test))\n",
    "labels = torch.LongTensor(batch_y_test)\n",
    "outputs = net(articles)\n",
    "_, predicted = torch.max(outputs.data, 1)\n",
    "total += labels.size(0)\n",
    "correct += (predicted == labels).sum()\n",
    "    \n",
    "print('Accuracy of the network on the 1180 test articles: %d %%' % (100 * correct / total))"
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}