SignLanguage-CUDA.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import random\n",
    "import torch\n",
    "\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=500):\n",
    "    X_train = X_train\n",
    "    Y_train = Y_train\n",
    "\n",
    "    train_accuracy = []\n",
    "    test_accuracy = []\n",
    "    for i in range(epochs):\n",
    "        model.zero_grad()\n",
    "        output = model(X_train.view(len(train_indices), 1, 64, 64))\n",
    "        loss = F.cross_entropy(output, Y_train)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "        tr_accuracy = test_model(model, train_indices, X_train, Y_train)\n",
    "        train_accuracy.append(tr_accuracy)\n",
    "        output_test = model(X_test.view(len(test_indices), 1, 64, 64))\n",
    "        loss_test = F.cross_entropy(output_test, Y_test)\n",
    "        tst_accuracy = test_model(model, test_indices, X_test, Y_test)\n",
    "        test_accuracy.append(tst_accuracy)\n",
    "    \n",
    "    return model, train_accuracy, test_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model(model, indices, X_samp, Y_samp):\n",
    "    output_test = model(X_samp.view(len(indices), 1, 64, 64))\n",
    "    total = 0\n",
    "    correct = 0\n",
    "    for i, out_t in enumerate(output_test):\n",
    "        if int(torch.argmax(out_t)) - int(Y_samp[i]) == 0:\n",
    "            correct = correct + 1\n",
    "        total = total + 1\n",
    "\n",
    "    return (correct/total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.load(\"datasets/sign-language/X.npy\")\n",
    "Y = np.load(\"datasets/sign-language/Y.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def partition_data(X, Y):\n",
    "    num_samples, _, _ = X.shape\n",
    "    samples_by_digit = {\n",
    "        0: [],\n",
    "        1: [],\n",
    "        2: [],\n",
    "        3: [],\n",
    "        4: [],\n",
    "        5: [],\n",
    "        6: [],\n",
    "        7: [],\n",
    "        8: [],\n",
    "        9: []\n",
    "    }\n",
    "    for i in range(num_samples):\n",
    "        samples_by_digit[np.argmax(Y[i])].append(i)\n",
    "    \n",
    "    train_indices = []\n",
    "    test_indices = []\n",
    "    for _, digit_sample_indices in samples_by_digit.items():\n",
    "        random.shuffle(digit_sample_indices)\n",
    "        train_indices = train_indices + digit_sample_indices[:int(0.8 * len(digit_sample_indices))]\n",
    "        test_indices = test_indices + digit_sample_indices[int(0.8 * len(digit_sample_indices)):]\n",
    "    \n",
    "    random.shuffle(train_indices)\n",
    "    random.shuffle(test_indices)\n",
    "    X_train = [X[i] for i in train_indices]\n",
    "    Y_train = [int(torch.argmax(torch.tensor(Y[i]))) for i in train_indices]\n",
    "    X_test = [X[i] for i in test_indices]\n",
    "    Y_test = [int(torch.argmax(torch.tensor(Y[i]))) for i in test_indices]\n",
    "    \n",
    "    return X_train, X_test, Y_train, Y_test, test_indices, train_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        # self.fc1 = nn.Linear(64*64, 192)\n",
    "        self.conv1 = nn.Conv2d(1, 18, kernel_size=3, stride=1, padding=1)\n",
    "        self.fc2 = nn.Linear(18*64*64, 192)\n",
    "        self.fc3 = nn.Linear(192, 192)\n",
    "        self.fc4 = nn.Linear(192, 192)\n",
    "        self.fc5 = nn.Linear(192, 192)\n",
    "        self.fc6 = nn.Linear(192, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = x.view(-1, 18*64*64)\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        x = F.relu(self.fc4(x))\n",
    "        x = F.relu(self.fc5(x))\n",
    "        x = self.fc6(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.load(\"datasets/sign-language/X.npy\")\n",
    "Y = np.load(\"datasets/sign-language/Y.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "X_train, X_test, Y_train, Y_test, test_indices, train_indices = partition_data(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = torch.tensor(X_train).float().to(device)\n",
    "Y_train = torch.tensor(Y_train).to(device)\n",
    "X_test = torch.tensor(X_test).float().to(device)\n",
    "Y_test = torch.tensor(Y_test).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = Net().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0961, 0.0952, 0.1009, 0.1076, 0.0968, 0.1066, 0.0999, 0.1017, 0.0975,\n",
       "         0.0977]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = net(X_train[0].view(1, 1, 64, 64))\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam([net.conv1.weight, net.fc2.weight, net.fc3.weight, net.fc4.weight, net.fc5.weight, net.fc6.weight], lr=0.001)\n",
    "net, train_accuracy, test_accuracy = train_model(net, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8181818181818182\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetTwo(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool = nn.MaxPool2d(2, stride=2)\n",
    "        self.dense = nn.Linear(32*32, 128)\n",
    "        self.dense_output = nn.Linear(128, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.max_pool(x)\n",
    "        x = x.view(-1, 1*32*32)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_two = NetTwo().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1006, 0.0852, 0.1090, 0.0925, 0.0935, 0.1007, 0.1003, 0.1124, 0.0986,\n",
       "         0.1072]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_two = net_two(X_train[0].view(1, 1, 64, 64))\n",
    "output_two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam([net_two.conv1.weight, net_two.dense.weight, net_two.dense_output.weight], lr=0.001)\n",
    "net_two, train_accuracy, test_accuracy = train_model(net_two, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7464114832535885\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_two, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetThree(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        self.conv2 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dense = nn.Linear(16*16, 128)\n",
    "        self.dense_output = nn.Linear(128, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.max_pool1(x)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.max_pool2(x)\n",
    "        x = x.view(-1, 1*16*16)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_three = NetThree().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1019, 0.0901, 0.0886, 0.1195, 0.1129, 0.0866, 0.0895, 0.0935, 0.1184,\n",
       "         0.0990]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_three = net_three(X_train[0].view(1, 1, 64, 64))\n",
    "output_three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_three.parameters(), lr=0.001)\n",
    "net_three, train_accuracy, test_accuracy = train_model(net_three, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7392344497607656\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_three, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_test = net_three(X_test.view(-1, 1, 64, 64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[[[-0.0941,  0.2357,  0.1852],\n",
       "          [-0.2312,  0.1925,  0.1058],\n",
       "          [-0.1028,  0.0574, -0.2448]]]], device='cuda:0', requires_grad=True)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net_three.conv1.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetFour(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        self.conv2 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        self.conv3 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dense = nn.Linear(8*8, 128)\n",
    "        self.dense_output = nn.Linear(128, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.max_pool1(x)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.max_pool2(x)\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = self.max_pool3(x)\n",
    "        x = x.view(-1, 1*8*8)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_four = NetFour().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1034, 0.1021, 0.0976, 0.0988, 0.0890, 0.0995, 0.1071, 0.0967, 0.1054,\n",
       "         0.1003]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_four = net_four(X_train[0].view(1, 1, 64, 64))\n",
    "output_four"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_four.parameters(), lr=0.001)\n",
    "net_four, train_accuracy, test_accuracy = train_model(net_four, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=3000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.10047846889952153\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_four, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetFive(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout1 = nn.Dropout2d(p=0.25)\n",
    "        self.conv2 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout2 = nn.Dropout2d(p=0.25)\n",
    "        self.conv3 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout3 = nn.Dropout2d(p=0.25)\n",
    "        self.dense = nn.Linear(8*8, 128)\n",
    "        self.dense_output = nn.Linear(128, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.max_pool1(x)\n",
    "        x = self.dropout1(x)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.max_pool2(x)\n",
    "        # x = self.dropout2(x)\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = self.max_pool3(x)\n",
    "        # x = self.dropout3(x)\n",
    "        x = x.view(-1, 1*8*8)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_five = NetFive().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0955, 0.0891, 0.0995, 0.1102, 0.1055, 0.1018, 0.0919, 0.1063, 0.1001,\n",
       "         0.1002]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_five = net_five(X_train[0].view(1, 1, 64, 64))\n",
    "output_five"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.RMSprop(net_five.parameters(), lr=0.001)\n",
    "net_five, train_accuracy, test_accuracy = train_model(net_five, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6244019138755981\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_five, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetSix(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 6, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        self.conv2 = nn.Conv2d(6, 12, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        self.conv3 = nn.Conv2d(12, 24, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dense = nn.Linear(24*8*8, 4096)\n",
    "        self.dense_output = nn.Linear(4096, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.max_pool1(x)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.max_pool2(x)\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = self.max_pool3(x)\n",
    "        x = x.view(-1, 24*8*8)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_six = NetSix().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1021, 0.0987, 0.1000, 0.0992, 0.1005, 0.0986, 0.0994, 0.1011, 0.1010,\n",
       "         0.0993]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = net_six(X_train[0].view(1, 1, 64, 64))\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_six.parameters(), lr=0.001)\n",
    "net_six, train_accuracy, test_accuracy = train_model(net_six, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9234449760765551\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_six, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetSeven(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 6, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout1 = nn.Dropout2d(p=0.25)\n",
    "        self.conv2 = nn.Conv2d(6, 12, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout2 = nn.Dropout2d(p=0.10)\n",
    "        self.conv3 = nn.Conv2d(12, 24, kernel_size=3, stride=1, padding=1)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout3 = nn.Dropout2d(p=0.05)\n",
    "        self.dense = nn.Linear(24*8*8, 4096)\n",
    "        self.dense_output = nn.Linear(4096, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.max_pool1(x)\n",
    "        x = self.dropout1(x)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.max_pool2(x)\n",
    "        x = self.dropout2(x)\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = self.max_pool3(x)\n",
    "        x = self.dropout3(x)\n",
    "        x = x.view(-1, 24*8*8)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_seven = NetSeven().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0995, 0.1006, 0.1020, 0.1004, 0.1017, 0.0955, 0.1004, 0.1013, 0.0996,\n",
       "         0.0989]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = net_seven(X_train[0].view(1, 1, 64, 64))\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_seven.parameters(), lr=0.001)\n",
    "net_seven, train_accuracy, test_accuracy = train_model(net_seven, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9210526315789473\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_seven, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetEight(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 6, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm1 = nn.BatchNorm2d(6)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        # self.dropout1 = nn.Dropout2d(p=0.25)\n",
    "        self.conv2 = nn.Conv2d(6, 12, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm2 = nn.BatchNorm2d(12)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        # self.dropout2 = nn.Dropout2d(p=0.10)\n",
    "        self.conv3 = nn.Conv2d(12, 24, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm3 = nn.BatchNorm2d(24)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, stride=2)\n",
    "        # self.dropout3 = nn.Dropout2d(p=0.05)\n",
    "        self.dense = nn.Linear(24*8*8, 4096)\n",
    "        self.dense_output = nn.Linear(4096, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.batch_norm1(self.conv1(x)))\n",
    "        x = self.max_pool1(x)\n",
    "        x = F.relu(self.batch_norm2(self.conv2(x)))\n",
    "        x = self.max_pool2(x)\n",
    "        x = F.relu(self.batch_norm3(self.conv3(x)))\n",
    "        x = self.max_pool3(x)\n",
    "        x = x.view(-1, 24*8*8)\n",
    "        x = F.relu(self.dense(x))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_eight = NetEight().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0796, 0.0892, 0.0813, 0.1056, 0.1092, 0.0782, 0.1723, 0.0769, 0.0900,\n",
       "         0.1177]], device='cuda:0', grad_fn=<SoftmaxBackward>)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = net_eight(X_train[0].view(1, 1, 64, 64))\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_eight.parameters(), lr=0.001)\n",
    "net_eight, train_accuracy, test_accuracy = train_model(net_eight, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9354066985645934\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_eight, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetNine(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(1, 18, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm1 = nn.BatchNorm2d(18)\n",
    "        self.fc2 = nn.Linear(18*64*64, 192)\n",
    "        self.batch_norm2 = nn.BatchNorm1d(192)\n",
    "        self.fc3 = nn.Linear(192, 192)\n",
    "        self.batch_norm3 = nn.BatchNorm1d(192)\n",
    "        self.fc4 = nn.Linear(192, 192)\n",
    "        self.batch_norm4 = nn.BatchNorm1d(192)\n",
    "        self.fc5 = nn.Linear(192, 192)\n",
    "        self.batch_norm5 = nn.BatchNorm1d(192)\n",
    "        self.fc6 = nn.Linear(192, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.batch_norm1(self.conv1(x)))\n",
    "        x = x.view(-1, 18*64*64)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(self.batch_norm2(x))\n",
    "        x = F.relu(self.batch_norm3(self.fc3(x)))\n",
    "        x = F.relu(self.batch_norm4(self.fc4(x)))\n",
    "        x = F.relu(self.batch_norm5(self.fc5(x)))\n",
    "        x = self.fc6(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_nine = NetNine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_nine.parameters(), lr=0.001)\n",
    "net_nine, train_accuracy, test_accuracy = train_model(net_nine, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8349282296650717\n"
     ]
    }
   ],
   "source": [
    "test_result = test_model(net_nine, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetTen(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1, 6, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm1 = nn.BatchNorm2d(6)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout1 = nn.Dropout2d(p=0.25)\n",
    "        self.conv2 = nn.Conv2d(6, 12, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm2 = nn.BatchNorm2d(12)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout2 = nn.Dropout2d(p=0.10)\n",
    "        self.conv3 = nn.Conv2d(12, 24, kernel_size=3, stride=1, padding=1)\n",
    "        self.batch_norm3 = nn.BatchNorm2d(24)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, stride=2)\n",
    "        self.dropout3 = nn.Dropout2d(p=0.05)\n",
    "        self.dense = nn.Linear(24*8*8, 4096)\n",
    "        self.batch_norm4 = nn.BatchNorm1d(4096)\n",
    "        self.dense_output = nn.Linear(4096, 10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.batch_norm1(self.conv1(x)))\n",
    "        x = self.dropout1(self.max_pool1(x))\n",
    "        x = F.relu(self.batch_norm2(self.conv2(x)))\n",
    "        x = self.dropout2(self.max_pool2(x))\n",
    "        x = F.relu(self.batch_norm3(self.conv3(x)))\n",
    "        x = self.dropout3(self.max_pool3(x))\n",
    "        x = x.view(-1, 24*8*8)\n",
    "        x = F.relu(self.batch_norm4(self.dense(x)))\n",
    "        x = self.dense_output(x)\n",
    "        \n",
    "        return F.softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_ten = NetTen().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net_ten.parameters(), lr=0.001)\n",
    "net_ten, train_accuracy, test_accuracy = train_model(net_ten, optimizer, train_indices, test_indices, X_train, Y_train, X_test, Y_test, epochs=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(train_accuracy, \"b-\", label=\"Train Accuracy\")\n",
    "ax.plot(test_accuracy, \"r-\", label=\"Test Accuracy\")\n",
    "leg = ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_result = test_model(net_ten, test_indices, X_test, Y_test)\n",
    "print(test_result)"
   ]
  },
  {
   "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
}