Logistic regression and Neural Network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import numpy as np\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60000\n",
      "600\n",
      "Epoch [1/20], Iteration [100/600], Loss: 2.1939\n",
      "Epoch [1/20], Iteration [200/600], Loss: 2.0933\n",
      "Epoch [1/20], Iteration [300/600], Loss: 1.9931\n",
      "Epoch [1/20], Iteration [400/600], Loss: 1.9060\n",
      "Epoch [1/20], Iteration [500/600], Loss: 1.8546\n",
      "Epoch [1/20], Iteration [600/600], Loss: 1.8569\n",
      "Epoch [6/20], Iteration [100/600], Loss: 1.1003\n",
      "Epoch [6/20], Iteration [200/600], Loss: 0.9031\n",
      "Epoch [6/20], Iteration [300/600], Loss: 0.9449\n",
      "Epoch [6/20], Iteration [400/600], Loss: 0.9166\n",
      "Epoch [6/20], Iteration [500/600], Loss: 0.8977\n",
      "Epoch [6/20], Iteration [600/600], Loss: 0.8527\n",
      "Epoch [11/20], Iteration [100/600], Loss: 0.7223\n",
      "Epoch [11/20], Iteration [200/600], Loss: 0.6693\n",
      "Epoch [11/20], Iteration [300/600], Loss: 0.7644\n",
      "Epoch [11/20], Iteration [400/600], Loss: 0.7312\n",
      "Epoch [11/20], Iteration [500/600], Loss: 0.8660\n",
      "Epoch [11/20], Iteration [600/600], Loss: 0.6407\n",
      "Epoch [16/20], Iteration [100/600], Loss: 0.6034\n",
      "Epoch [16/20], Iteration [200/600], Loss: 0.6197\n",
      "Epoch [16/20], Iteration [300/600], Loss: 0.6956\n",
      "Epoch [16/20], Iteration [400/600], Loss: 0.6883\n",
      "Epoch [16/20], Iteration [500/600], Loss: 0.5473\n",
      "Epoch [16/20], Iteration [600/600], Loss: 0.5219\n",
      "Accuracy of the model on the 10000 test images: 87 %\n"
     ]
    }
   ],
   "source": [
    "input_size = 784#here we are going to use PyTorch MNIST dataset. Will talk of custom dataset afterwards. Size of image is 28x28, hence if we make them a 1-D vector then it is 784\n",
    "output_size = 10#total possible output 0-9\n",
    "num_epochs = 20\n",
    "batch_size = 100#total number of images is 60000\n",
    "learning_rate = 0.001\n",
    "#here we are using PyTorch dataset hence torchvision.datasets.MNIST, then the image is normal array to convert them to tensor we use transforms.ToTensor()\n",
    "#later we will see that we can include many other transforms here also.\n",
    "train_dataset = torchvision.datasets.MNIST(root='Data', train = True, transform = transforms.ToTensor(), download = True) \n",
    "test_dataset = torchvision.datasets.MNIST(root='Data', train = False, transform= transforms.ToTensor())\n",
    "train_loader = torch.utils.data.DataLoader(dataset = train_dataset, batch_size = batch_size, shuffle = True)\n",
    "test_loader = torch.utils.data.DataLoader(dataset = test_dataset, batch_size = batch_size, shuffle = False)                                          \n",
    "\n",
    "#in DataLoader we use toch.utils.data.DataLoader(), then we define batch_size and shuffle here. \n",
    "#Basically it divides the dataset and loads data in batches\n",
    "\n",
    "class Logistic(nn.Module):\n",
    "    def __init__(self, input_size, output_size):\n",
    "        super(Logistic, self).__init__()\n",
    "        self.linear = nn.Linear(input_size, output_size)\n",
    "    def forward(self, x):\n",
    "        out = self.linear(x)\n",
    "        return(out)\n",
    "        \n",
    "        \n",
    "\n",
    "model = Logistic(input_size, output_size)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()#this could be nn.BCELoss() if we were using it for binary classification\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)\n",
    "\n",
    "print(len(train_dataset))\n",
    "print(len(train_loader))\n",
    "\n",
    "total_step = len(train_loader)#this will give total number of iteration.\n",
    "for epoch in range(num_epochs):\n",
    "    for i, (images, labels) in enumerate(train_loader):#enumerate is used to give the value of i also. \n",
    "        images = images.reshape(-1, 28*28)#600,784\n",
    "        outputs = model(images)\n",
    "        loss = criterion(outputs, labels)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if(epoch%5 == 0):\n",
    "            if (i+1) % 100 == 0:\n",
    "                print ('Epoch [{}/{}], Iteration [{}/{}], Loss: {:.4f}' \n",
    "                       .format(epoch+1, num_epochs, i+1, total_step, loss.item()))\n",
    "\n",
    "with torch.no_grad():\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for images, labels in test_loader:\n",
    "        images = images.reshape(-1, 28*28)\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs.data, 1) #return max value and the indices\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted==labels).sum()\n",
    "    print('Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total)) \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/5], Iteration [100/600], Loss: 0.3462\n",
      "Epoch [1/5], Iteration [200/600], Loss: 0.3088\n",
      "Epoch [1/5], Iteration [300/600], Loss: 0.2861\n",
      "Epoch [1/5], Iteration [400/600], Loss: 0.1597\n",
      "Epoch [1/5], Iteration [500/600], Loss: 0.3207\n",
      "Epoch [1/5], Iteration [600/600], Loss: 0.1445\n",
      "Epoch [2/5], Iteration [100/600], Loss: 0.1394\n",
      "Epoch [2/5], Iteration [200/600], Loss: 0.1824\n",
      "Epoch [2/5], Iteration [300/600], Loss: 0.1940\n",
      "Epoch [2/5], Iteration [400/600], Loss: 0.1417\n",
      "Epoch [2/5], Iteration [500/600], Loss: 0.0526\n",
      "Epoch [2/5], Iteration [600/600], Loss: 0.2374\n",
      "Epoch [3/5], Iteration [100/600], Loss: 0.1548\n",
      "Epoch [3/5], Iteration [200/600], Loss: 0.1229\n",
      "Epoch [3/5], Iteration [300/600], Loss: 0.0985\n",
      "Epoch [3/5], Iteration [400/600], Loss: 0.0805\n",
      "Epoch [3/5], Iteration [500/600], Loss: 0.1887\n",
      "Epoch [3/5], Iteration [600/600], Loss: 0.1625\n",
      "Epoch [4/5], Iteration [100/600], Loss: 0.1755\n",
      "Epoch [4/5], Iteration [200/600], Loss: 0.0969\n",
      "Epoch [4/5], Iteration [300/600], Loss: 0.0539\n",
      "Epoch [4/5], Iteration [400/600], Loss: 0.0600\n",
      "Epoch [4/5], Iteration [500/600], Loss: 0.0893\n",
      "Epoch [4/5], Iteration [600/600], Loss: 0.1310\n",
      "Epoch [5/5], Iteration [100/600], Loss: 0.0916\n",
      "Epoch [5/5], Iteration [200/600], Loss: 0.1421\n",
      "Epoch [5/5], Iteration [300/600], Loss: 0.1182\n",
      "Epoch [5/5], Iteration [400/600], Loss: 0.1086\n",
      "Epoch [5/5], Iteration [500/600], Loss: 0.0648\n",
      "Epoch [5/5], Iteration [600/600], Loss: 0.1162\n",
      "Accuracy of the network on the 10000 test images: 97 %\n"
     ]
    }
   ],
   "source": [
    "#Write Neural Network By yourself. With HyperParameters\n",
    "\n",
    "input_size = 784\n",
    "hidden_size = 100\n",
    "num_classes = 10\n",
    "learning_rate = 0.001\n",
    "num_epochs = 5\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "class NeuralNet(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_classes):\n",
    "        super(NeuralNet, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.fc2 = nn.Linear(hidden_size, num_classes)\n",
    "    def forward(self, x):\n",
    "        out = self.fc1(x)\n",
    "        out = self.relu(out)\n",
    "        out = self.fc2(out)\n",
    "        return out\n",
    "    \n",
    "model = NeuralNet(input_size, hidden_size, num_classes).to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(),lr = learning_rate)\n",
    "\n",
    "total_step = len(train_loader)\n",
    "for epoch in range(num_epochs):\n",
    "    for i, (images, labels) in enumerate(train_loader):\n",
    "        images = images.reshape(-1,28*28).to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(images)\n",
    "        loss = criterion(outputs, labels)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if (i+1) % 100 == 0:\n",
    "            print ('Epoch [{}/{}], Iteration [{}/{}], Loss: {:.4f}' \n",
    "                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))\n",
    "\n",
    "with torch.no_grad():\n",
    "    correct = 0 \n",
    "    total = 0\n",
    "    for images, labels in (test_loader):\n",
    "        images= images.reshape(-1, 28*28).to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total+=predicted.size(0)\n",
    "        correct += (predicted==labels).sum()\n",
    "        \n",
    "    print('Accuracy of the network on the 10000 test images: {} %'.format(100 * correct / total))"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}