aslProj.ipynb

{
 "metadata": {
  "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.8.5-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "Python 3.8.5 64-bit",
   "display_name": "Python 3.8.5 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "bd626630af7502351b1eb52141596e48201686a4c734972bbcb7e8fdedff9114"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "\n",
    "import numpy as np\n",
    "# import pandas as pd\n",
    "# from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
    "# from sklearn.model_selection import train_test_split\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import DataLoader,SubsetRandomSampler\n",
    "from torchvision.datasets import  ImageFolder\n",
    "from torchvision import transforms\n",
    "from PIL import Image\n",
    "import torchvision\n",
    "import matplotlib.pyplot as plt \n",
    "from torch.optim import SGD\n",
    "import torch.nn as nn \n",
    "# from scipy.signal import savgol_filter\n",
    "import time as time\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'\\n    2. LOADING AND NORMALIZING DATASET\\n'"
      ]
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "\"\"\"\n",
    "    2. LOADING AND NORMALIZING DATASET\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getStats(path):\n",
    "    \"\"\"\n",
    "        Input:\n",
    "        path --> Path to Image Folder\n",
    "\n",
    "        Returns:\n",
    "        avg --> mean of channels\n",
    "        std --> stdDev of channels\n",
    "        transform --> transform of images/tensors\n",
    "    \"\"\"\n",
    "    # temporary ds to find mean and std\n",
    "    tempDS = ImageFolder(path)\n",
    "\n",
    "    # find avg and std in ds\n",
    "    avg = [0,0,0]; std = [0,0,0]\n",
    "    for pic in tempDS:\n",
    "        # PIL needs pixel value b/w 0 and 1.\n",
    "        img = np.asarray(pic[0])/255\n",
    "        for i in range(3):\n",
    "            avg[i] += (img[:,:,i].mean())/len(tempDS)\n",
    "            std[i] += ((img[:,:,i]).std())/(len(tempDS))\n",
    "    print(f'AVGS: {avg} \\nSTDS: {std}')\n",
    "    # transform each image to a tensor and normalize\n",
    "    transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),transforms.Normalize(avg,std)]\n",
    ")\n",
    "    return avg,std,transform\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "AVGS: [0.6282307923169269, 0.5358974006269173, 0.4953553087901827] \nSTDS: [0.18799243292129267, 0.20690560403400501, 0.20573593318662114]\n"
     ]
    }
   ],
   "source": [
    "\"# My dataset values\"\n",
    "myAvg, myStd, transform = getStats(path=\"./letters\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\"# create loader object for personal pictures\"\n",
    "trainSet = ImageFolder('./letters',transform=transform)\n",
    "trainLoader = DataLoader(trainSet,batch_size=4,shuffle=True)\n",
    "classes = ['A','B','C','D','E','F','G','H','I','K']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"# de-Normalize images (0,1) --> (0,255)\"\n",
    "def helpShow(img):\n",
    "    # unnormalize images\n",
    "    for i in range(3):\n",
    "        img[:,:,i] = img[:,:,i]*myStd[i] + myAvg[i]\n",
    "    npImg = img.numpy()\n",
    "    plt.imshow(np.transpose(npImg,(1,2,0)))\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Letters:     B\t    I\t    I\t    C\n"
     ]
    }
   ],
   "source": [
    "dataIter = iter(trainLoader)\n",
    "\n",
    "images, labels = dataIter.next()\n",
    "\n",
    "helpShow(torchvision.utils.make_grid(images))\n",
    "print('Letters:','\\t'.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"PART 3 BEGINS\"\"\"\n",
    "\n",
    "\"\"\"MODEL FOR PERSONAL PCITURES\"\"\"\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN,self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels=3,out_channels=4,kernel_size=3,stride=1)\n",
    "        self.conv2 = nn.Conv2d(in_channels=4,out_channels=8,kernel_size=5,stride=1)\n",
    "\n",
    "        self.pool = nn.MaxPool2d(2,2)\n",
    "        # need to pad 1 pixel b/c dims become odd later\n",
    "\n",
    "        self.poolE = nn.MaxPool2d(2,2,padding=1)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "        self.fc1 = nn.Linear(12*12*8,32)\n",
    "        self.fc2 = nn.Linear(32,18)\n",
    "        self.fc3 = nn.Linear(18,10)\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "    def forward(self,x):\n",
    "        x = self.pool(self.relu(self.conv1(x)))\n",
    "        x = self.poolE(self.relu(self.conv2(x)))\n",
    "        x = x.view(-1,12*12*8) \n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = (self.fc3(x))\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadModel(lr,loss=' '):\n",
    "\n",
    "    torch.manual_seed(seed=0)\n",
    "    model = CNN()\n",
    "    optimizer = SGD(model.parameters(),lr)\n",
    "    lossFxn = nn.MSELoss()\n",
    "    if loss == 'ce':\n",
    "        lossFxn = nn.CrossEntropyLoss()\n",
    "    \n",
    "    return model, optimizer, lossFxn\n",
    "\n",
    "def loadData(batchSize):\n",
    "    trainSet = ImageFolder('./letters',transform=transform)\n",
    "    trainLoader = DataLoader(trainSet,batch_size=batchSize)\n",
    "\n",
    "    return trainLoader\n",
    "\n",
    "\n",
    "def tenToOneHot(argument):\n",
    "    switcher = {\n",
    "        0: [1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],\n",
    "        1: [0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],\n",
    "        2: [0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],\n",
    "        3: [0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0],\n",
    "        4: [0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0],\n",
    "        5: [0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0],\n",
    "        6: [0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0],\n",
    "        7: [0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0],\n",
    "        8: [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0],\n",
    "        9: [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0]}\n",
    "       \n",
    "    return (switcher[argument])\n",
    "\n",
    "# Accuracy Function\n",
    "def acc(pred,labels):\n",
    "    numSamp = labels.size()[0]\n",
    "    val, idx = torch.max(pred.data,1)\n",
    "    correct = (idx == labels).sum().item()\n",
    "    return correct/numSamp\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"TRAINING FUNCTION FOR MY OWN DATASET\"\"\"\n",
    "def train(lr,batchSize,epochs,loss=None):\n",
    "    model, optimizer, criterion = loadModel(lr=lr,loss=loss)\n",
    "    data = loadData(batchSize=batchSize)\n",
    "    trainAcc, trainLoss = [],[]\n",
    "\n",
    "    tic = time.time()\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "\n",
    "        runningAcc = 0; runningLoss = 0\n",
    "        cnt = 0\n",
    "\n",
    "        for idx, (inputs,labels) in enumerate(data,0):\n",
    "            inputs, labels = inputs.float() , labels.float()\n",
    "\n",
    "            # zero the gradients\n",
    "            optimizer.zero_grad()\n",
    "            # get predictions \n",
    "            outputs = model(inputs)\n",
    "            # print(outputs)\n",
    "            # create a label tensor that is the same size as the output\n",
    "            labelsOneHot = torch.zeros([outputs.size()[0],outputs.size()[1]])\n",
    "            for i in range(10):\n",
    "                labelsOneHot[i,:] = torch.FloatTensor(\n",
    "                    tenToOneHot(labels[i].item())\n",
    "                )\n",
    "            \n",
    "            # compute loss\n",
    "            loss = criterion(outputs.squeeze(),labelsOneHot)\n",
    "            # optimize\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            runningLoss += loss.item()\n",
    "            runningAcc += acc(outputs,labels)\n",
    "            cnt += 1\n",
    "\n",
    "        trainLoss += [runningLoss/cnt]\n",
    "        trainAcc += [runningAcc/cnt]\n",
    "        if runningAcc/cnt == 1.0:\n",
    "            print(f\"100% accuracy achieved at epoch: {epoch}\")\n",
    "\n",
    "    print(trainAcc[-1])\n",
    "    toc = time.time()\n",
    "    totalTime = toc - tic\n",
    "\n",
    "    print(f\"Total Time: {totalTime} seconds.\")\n",
    "\n",
    "    fig,ax = plt.subplots(2,1,sharex=True)\n",
    "    epochList = list(range(epochs))\n",
    "    ax[0].plot(epochList,trainLoss,label='Training')\n",
    "    ax[1].plot(epochList,trainAcc,label='Training Set')\n",
    "    ax[0].set_ylabel('Loss'); ax[1].set_ylabel('Accuracy')\n",
    "    ax[1].set_xlabel('Epoch Num')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "batchSize = 10\n",
    "lr = 0.1\n",
    "epochs = 31"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0.6333333333333333\nTotal Time: 1.2346739768981934 seconds.\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "source": [
    "train(lr,batchSize,epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "AVGS: [0.6876337871321516, 0.6189555937053737, 0.5673832596603504] \nSTDS: [0.12917142914887608, 0.16189818592897234, 0.17227187253294954]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\"\"\"STATISTICS FOR ENTIRE CLASS DATASET\"\"\"\n",
    "\n",
    "cAvg,cStd,cTransform = getStats(\"./training_v2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from model1 import CNN_4Conv\n",
    "from model2 import CNN_2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def classLoadData(batchSize,shuffle=True,seed=0,validSplit = 0.2):\n",
    "    classTrain = ImageFolder(\"./training_v2\",transform=cTransform)\n",
    "    classSize = len(classTrain)\n",
    "    classIdxs = list(range(classSize))\n",
    "    if shuffle:\n",
    "        np.random.seed(seed)\n",
    "        np.random.shuffle(classIdxs)\n",
    "    split = int(np.floor(classSize*(1-validSplit)))\n",
    "    trainIdxs, validIdxs = classIdxs[:split], classIdxs[split:]\n",
    "\n",
    "    trainSampler = SubsetRandomSampler(trainIdxs)\n",
    "    validSampler = SubsetRandomSampler(validIdxs)\n",
    "\n",
    "    trainLoader = DataLoader(classTrain,batch_size=batchSize,sampler=trainSampler)\n",
    "    validLoader = DataLoader(classTrain,batch_size=batchSize,sampler=validSampler)\n",
    "\n",
    "    return trainLoader,validLoader\n",
    "\n",
    "\n",
    "\n",
    "def classLoadModel(lr,numConv,batchNorm,outKernels,linDim,loss=None):\n",
    "    torch.manual_seed(seed=0)\n",
    "    if numConv == 4:\n",
    "        model = CNN_4Conv(batchNorm=batchNorm,outKernels=outKernels,linDim=linDim)\n",
    "    elif numConv == 2:\n",
    "        model = CNN_2Conv(batchNorm=batchNorm,outKernels=outKernels,linDim=linDim)\n",
    "    optimizer = SGD(model.parameters(),lr)\n",
    "    if loss == 'ce':\n",
    "        lossFxn = nn.CrossEntropyLoss()\n",
    "    elif loss == 'mse':\n",
    "        lossFxn = nn.MSELoss()\n",
    "    \n",
    "    return model, optimizer, lossFxn\n",
    "\n",
    "\n",
    "\n",
    "def evalModel(model,validLoader,loss):\n",
    "\n",
    "    if loss == 'ce':\n",
    "        criterion = nn.CrossEntropyLoss()\n",
    "    elif loss == 'mse':\n",
    "        criterion = nn.MSELoss()\n",
    "\n",
    "    runningValidAcc, runningValidLoss = 0,0\n",
    "    cnt = 0\n",
    "    for idx, (inputs,labels) in enumerate(validLoader):\n",
    "        # print(f\"    Validation Iteration: {cnt+1}\")\n",
    "        # ins and labs\n",
    "        inputs = inputs.float(); \n",
    "        #outs\n",
    "        outputs = model(inputs)\n",
    "        # change labels to be same size as outputs\n",
    "        if loss == 'mse':\n",
    "            labelsOneHot = torch.zeros([outputs.size()[0],outputs.size()[1]])\n",
    "            for i in range(labels.size()[0]):\n",
    "                labelsOneHot[i,:] = torch.FloatTensor(\n",
    "                    tenToOneHot(labels[i].item())\n",
    "                )\n",
    "            validLoss = criterion(outputs.squeeze(),labelsOneHot.float())\n",
    "        elif loss == 'ce':\n",
    "            validLoss = criterion(outputs.squeeze(),labels)\n",
    "        # get loss\n",
    "        \n",
    "        runningValidLoss += validLoss.item()\n",
    "\n",
    "        runningValidAcc += acc(outputs,labels)\n",
    "        cnt += 1\n",
    "\n",
    "    return runningValidLoss/cnt,runningValidAcc/cnt\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training for entire class dataset\n",
    "\n",
    "def classTV_Train(lr,batchSize,lossType,epochs,numConv,batchNorm,outKernels,linDim):\n",
    "    model, optimizer, criterion = classLoadModel(lr=lr,loss=lossType,numConv=numConv,batchNorm=batchNorm,outKernels=outKernels,linDim=linDim)\n",
    "    trainLoader, validLoader = classLoadData(batchSize=batchSize)\n",
    "\n",
    "    trainAcc, validAcc, trainLoss, validLoss = [],[],[],[]\n",
    "\n",
    "    tic = time.time()\n",
    "\n",
    "    myPreds = []\n",
    "    realPreds = []\n",
    "    for epoch in range(epochs):\n",
    "        epochTime = time.time() - tic\n",
    "\n",
    "        print(f\"At Epoch: {epoch}\\nTime since start: {epochTime}\")\n",
    "        runningTrainAcc, runningTrainLoss = 0,0\n",
    "        runningValidAcc, runningValidLoss = 0,0\n",
    "        cnt = 0\n",
    "\n",
    "        for idx, (inputs,labels) in enumerate(trainLoader):\n",
    "            # print(f\"    Training Iteration: {cnt+1}\")\n",
    "            # labels of shape 4x1\n",
    "            inputs = inputs.float(); \n",
    "            \n",
    "            # zero gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # get outputs of shape # bs x 10\n",
    "            outputs = model(inputs)\n",
    "            realPreds += labels.tolist()\n",
    "            \n",
    "            val,idx = torch.max(outputs.data,1)\n",
    "            myPreds += idx.tolist()\n",
    "            \n",
    "            if lossType == 'mse':\n",
    "                labelsOneHot = torch.zeros([outputs.size()[0],outputs.size()[1]])\n",
    "                for i in range(labels.size()[0]):\n",
    "                    labelsOneHot[i,:] = torch.FloatTensor(\n",
    "                        tenToOneHot(labels[i].item())\n",
    "                    )\n",
    "                loss = criterion(outputs.squeeze(),labelsOneHot.float())\n",
    "            \n",
    "            \n",
    "\n",
    "\n",
    "            elif lossType == 'ce':\n",
    "                loss = criterion(outputs.squeeze(),labels)\n",
    "            \n",
    "            # compute loss\n",
    "            \n",
    "            # optimize\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            runningTrainLoss += loss.item()\n",
    "            runningTrainAcc += acc(outputs,labels)\n",
    "            cnt += 1\n",
    "    \n",
    "\n",
    "        batchValidLoss, batchValidAcc = evalModel(model,validLoader,loss=lossType)\n",
    "\n",
    "        trainAcc += [runningTrainAcc/cnt]; trainLoss += [runningTrainLoss/cnt]\n",
    "        validAcc += [batchValidAcc]; validLoss += [batchValidLoss]\n",
    "        print(f\"Train Accuracy at epoch {epoch}: {trainAcc[epoch]}\")\n",
    "        print(f\"Valid Accuracy at epoch {epoch}: {validAcc[epoch]}\")\n",
    "        print(f\"Train Loss at epoch {epoch}: {trainLoss[epoch]}\")\n",
    "        print(f\"Valid Loss at epoch {epoch}: {validLoss[epoch]}\\n\")\n",
    "\n",
    "    toc = time.time()\n",
    "    print(f\"Total Training Time: {(toc-tic)}\")\n",
    "    fig,ax = plt.subplots(2,1,sharex=True)\n",
    "    axLoss = ax[0]; axAcc = ax[1]\n",
    "    epochList = list(range(epochs))\n",
    "    axLoss.plot(epochList,trainLoss,label='Training Set'); axLoss.plot(epochList,validLoss,label='Validation Set')\n",
    "    axAcc.plot(epochList,trainAcc,label='Training Set'); axAcc.plot(epochList,validAcc,label='Validation Set')\n",
    "    axLoss.set_ylabel('Loss'); axAcc.set_ylabel('Accuracy')\n",
    "    axAcc.set_xlabel('Epoch Num (n)')\n",
    "    plt.legend()\n",
    "\n",
    "\n",
    "    C = (confusion_matrix(y_true=realPreds,y_pred=myPreds))\n",
    "    classes = ['A','B','C','D','E','F','G','H','I','K']\n",
    "    m = 0\n",
    "    letters = []\n",
    "    for i in range(10):\n",
    "        for j in range(10):\n",
    "            if i == j:\n",
    "                continue\n",
    "            else:\n",
    "                if (C[i,j] + C[j,i]) > m:\n",
    "                    m = (C[i,j]+C[j,i])\n",
    "                    letters = [i,j]\n",
    "    print(letters)\n",
    "                \n",
    "\n",
    "\n",
    "    return model\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Hyperparameter Dicts\"\"\"\n",
    "h1 = {\"lr\": 0.01, \"batchSize\": 4,\"nnFirstLayer\":32,\"numConvLayer\": 2,\"numKernels\":10}\n",
    "\n",
    "h2 = {\"lr\": 0.1, \"batchSize\": 4,\"nnFirstLayer\":32,\"numConvLayer\": 2,\"numKernels\":10}\n",
    "\n",
    "h3 = {\"lr\": 0.01, \"batchSize\": 32,\"nnFirstLayer\":32,\"numConvLayer\": 2,\"numKernels\":10}\n",
    "\n",
    "h4 = {\"lr\": 0.1, \"batchSize\": 32,\"nnFirstLayer\":32,\"numConvLayer\": 2,\"numKernels\":10}\n",
    "# change model for h5, 30 kernels instead of 10...\n",
    "h5 = {\"lr\": 0.1, \"batchSize\": 32,\"nnFirstLayer\":32,\"numConvLayer\": 2,\"numKernels\":30}\n",
    "\n",
    "## change model for below--> number of conv layers = 4\n",
    "h6 = {\"lr\": 0.1, \"batchSize\": 32,\"nnFirstLayer\":8,\"numConvLayer\": 4,\"numKernels\":10}\n",
    "# change model kernels\n",
    "h7 = {\"lr\": 0.1, \"batchSize\": 32,\"nnFirstLayer\":8,\"numConvLayer\": 4,\"numKernels\":30}\n",
    "# change model nnFirstlayer and kernels\n",
    "h8 = {\"lr\": 0.01, \"batchSize\": 4,\"nnFirstLayer\":32,\"numConvLayer\": 4,\"numKernels\":10}\n",
    "\n",
    "h9 = {\"lr\": 0.1, \"batchSize\": 4,\"nnFirstLayer\":32,\"numConvLayer\": 4,\"numKernels\":10}\n",
    "\n",
    "h10 = {\"lr\": 0.01, \"batchSize\": 32,\"nnFirstLayer\":32,\"numConvLayer\": 4,\"numKernels\":10}\n",
    "\n",
    "h11 = {\"lr\": 0.1, \"batchSize\": 32,\"nnFirstLayer\":32,\"numConvLayer\": 4,\"numKernels\":10}\n",
    "# change model kernels\n",
    "h12 = {\"lr\": 0.1, \"batchSize\": 32,\"nnFirstLayer\":32,\"numConvLayer\": 4,\"numKernels\":30}\n",
    "\n",
    "if (h1 != h2 != h3 != h4 != h5 != h6 != h7 != h8 != h9 != h10 != h11 != h12):\n",
    "    print(True)       \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "At Epoch: 0\n",
      "Time since start: 0.0\n",
      "Train Accuracy at epoch 0: 0.10517693315858453\n",
      "Valid Accuracy at epoch 0: 0.10602094240837696\n",
      "Train Loss at epoch 0: 2.304116530937105\n",
      "Valid Loss at epoch 0: 2.296264010574181\n",
      "\n",
      "At Epoch: 1\n",
      "Time since start: 13.498900651931763\n",
      "Train Accuracy at epoch 1: 0.11762778505897772\n",
      "Valid Accuracy at epoch 1: 0.14267015706806283\n",
      "Train Loss at epoch 1: 2.292137273485976\n",
      "Valid Loss at epoch 1: 2.271438245373871\n",
      "\n",
      "At Epoch: 2\n",
      "Time since start: 28.697295427322388\n",
      "Train Accuracy at epoch 2: 0.30307994757536044\n",
      "Valid Accuracy at epoch 2: 0.2683246073298429\n",
      "Train Loss at epoch 2: 1.9173258869551113\n",
      "Valid Loss at epoch 2: 2.309081588115992\n",
      "\n",
      "At Epoch: 3\n",
      "Time since start: 45.281917095184326\n",
      "Train Accuracy at epoch 3: 0.5468545216251638\n",
      "Valid Accuracy at epoch 3: 0.650087260034904\n",
      "Train Loss at epoch 3: 1.2624890474629433\n",
      "Valid Loss at epoch 3: 1.0302403752560392\n",
      "\n",
      "At Epoch: 4\n",
      "Time since start: 61.841387033462524\n",
      "Train Accuracy at epoch 4: 0.6890563564875491\n",
      "Valid Accuracy at epoch 4: 0.7460732984293194\n",
      "Train Loss at epoch 4: 0.9148333991705629\n",
      "Valid Loss at epoch 4: 0.7956651601920889\n",
      "\n",
      "At Epoch: 5\n",
      "Time since start: 78.55259704589844\n",
      "Train Accuracy at epoch 5: 0.7545871559633027\n",
      "Valid Accuracy at epoch 5: 0.7665794066317626\n",
      "Train Loss at epoch 5: 0.7218921114820291\n",
      "Valid Loss at epoch 5: 0.7790948869197274\n",
      "\n",
      "At Epoch: 6\n",
      "Time since start: 95.09336638450623\n",
      "Train Accuracy at epoch 6: 0.8007863695937091\n",
      "Valid Accuracy at epoch 6: 0.8298429319371727\n",
      "Train Loss at epoch 6: 0.5975003568238156\n",
      "Valid Loss at epoch 6: 0.5585919306113711\n",
      "\n",
      "At Epoch: 7\n",
      "Time since start: 111.86950874328613\n",
      "Train Accuracy at epoch 7: 0.8227391874180865\n",
      "Valid Accuracy at epoch 7: 0.8267888307155322\n",
      "Train Loss at epoch 7: 0.5193294551355342\n",
      "Valid Loss at epoch 7: 0.5157807562302149\n",
      "\n",
      "At Epoch: 8\n",
      "Time since start: 127.47079491615295\n",
      "Train Accuracy at epoch 8: 0.8469855832241153\n",
      "Valid Accuracy at epoch 8: 0.8529668411867364\n",
      "Train Loss at epoch 8: 0.44752515829885364\n",
      "Valid Loss at epoch 8: 0.4510229719200547\n",
      "\n",
      "At Epoch: 9\n",
      "Time since start: 143.13191628456116\n",
      "Train Accuracy at epoch 9: 0.854521625163827\n",
      "Valid Accuracy at epoch 9: 0.8490401396160558\n",
      "Train Loss at epoch 9: 0.40801086355067717\n",
      "Valid Loss at epoch 9: 0.4736249503086526\n",
      "\n",
      "At Epoch: 10\n",
      "Time since start: 160.849538564682\n",
      "Train Accuracy at epoch 10: 0.8790956749672346\n",
      "Valid Accuracy at epoch 10: 0.8102094240837696\n",
      "Train Loss at epoch 10: 0.3447159570823381\n",
      "Valid Loss at epoch 10: 0.5548462667721884\n",
      "\n",
      "At Epoch: 11\n",
      "Time since start: 177.22774481773376\n",
      "Train Accuracy at epoch 11: 0.8849934469200524\n",
      "Valid Accuracy at epoch 11: 0.8730366492146597\n",
      "Train Loss at epoch 11: 0.3268773105074647\n",
      "Valid Loss at epoch 11: 0.4132931260341405\n",
      "\n",
      "At Epoch: 12\n",
      "Time since start: 192.9905972480774\n",
      "Train Accuracy at epoch 12: 0.9030144167758847\n",
      "Valid Accuracy at epoch 12: 0.8765270506108201\n",
      "Train Loss at epoch 12: 0.2875615575740919\n",
      "Valid Loss at epoch 12: 0.4331500067961334\n",
      "\n",
      "At Epoch: 13\n",
      "Time since start: 209.17939972877502\n",
      "Train Accuracy at epoch 13: 0.8974442988204456\n",
      "Valid Accuracy at epoch 13: 0.8507853403141361\n",
      "Train Loss at epoch 13: 0.27937597114900314\n",
      "Valid Loss at epoch 13: 0.5225306565736796\n",
      "\n",
      "At Epoch: 14\n",
      "Time since start: 224.71884870529175\n",
      "Train Accuracy at epoch 14: 0.908256880733945\n",
      "Valid Accuracy at epoch 14: 0.9057591623036649\n",
      "Train Loss at epoch 14: 0.25073794866910853\n",
      "Valid Loss at epoch 14: 0.3426495259733411\n",
      "\n",
      "At Epoch: 15\n",
      "Time since start: 241.23299193382263\n",
      "Train Accuracy at epoch 15: 0.9187418086500655\n",
      "Valid Accuracy at epoch 15: 0.8717277486910995\n",
      "Train Loss at epoch 15: 0.22507392208986085\n",
      "Valid Loss at epoch 15: 0.4746004877589443\n",
      "\n",
      "At Epoch: 16\n",
      "Time since start: 257.2292559146881\n",
      "Train Accuracy at epoch 16: 0.926605504587156\n",
      "Valid Accuracy at epoch 16: 0.9031413612565445\n",
      "Train Loss at epoch 16: 0.2089898908224542\n",
      "Valid Loss at epoch 16: 0.3525172938616307\n",
      "\n",
      "At Epoch: 17\n",
      "Time since start: 272.49639797210693\n",
      "Train Accuracy at epoch 17: 0.9311926605504587\n",
      "Valid Accuracy at epoch 17: 0.8651832460732984\n",
      "Train Loss at epoch 17: 0.18991950263152782\n",
      "Valid Loss at epoch 17: 0.47711690348637487\n",
      "\n",
      "At Epoch: 18\n",
      "Time since start: 287.99698638916016\n",
      "Train Accuracy at epoch 18: 0.9416775884665793\n",
      "Valid Accuracy at epoch 18: 0.8835078534031413\n",
      "Train Loss at epoch 18: 0.1670953496593844\n",
      "Valid Loss at epoch 18: 0.43801779438803323\n",
      "\n",
      "At Epoch: 19\n",
      "Time since start: 304.3222975730896\n",
      "Train Accuracy at epoch 19: 0.9482306684141546\n",
      "Valid Accuracy at epoch 19: 0.9057591623036649\n",
      "Train Loss at epoch 19: 0.1524407611629105\n",
      "Valid Loss at epoch 19: 0.37010735114305343\n",
      "\n",
      "At Epoch: 20\n",
      "Time since start: 320.68155574798584\n",
      "Train Accuracy at epoch 20: 0.9492136304062909\n",
      "Valid Accuracy at epoch 20: 0.8656195462478186\n",
      "Train Loss at epoch 20: 0.1388810532538393\n",
      "Valid Loss at epoch 20: 0.5545266057619235\n",
      "\n",
      "At Epoch: 21\n",
      "Time since start: 337.69509744644165\n",
      "Train Accuracy at epoch 21: 0.9626474442988204\n",
      "Valid Accuracy at epoch 21: 0.9201570680628273\n",
      "Train Loss at epoch 21: 0.11395873512213786\n",
      "Valid Loss at epoch 21: 0.3689159645938824\n",
      "\n",
      "At Epoch: 22\n",
      "Time since start: 355.20069003105164\n",
      "Train Accuracy at epoch 22: 0.9580602883355177\n",
      "Valid Accuracy at epoch 22: 0.8965968586387435\n",
      "Train Loss at epoch 22: 0.11337139188278848\n",
      "Valid Loss at epoch 22: 0.43993813540399307\n",
      "\n",
      "At Epoch: 23\n",
      "Time since start: 375.48744678497314\n",
      "Train Accuracy at epoch 23: 0.9518348623853211\n",
      "Valid Accuracy at epoch 23: 0.887434554973822\n",
      "Train Loss at epoch 23: 0.12953708907020564\n",
      "Valid Loss at epoch 23: 0.5596078456421288\n",
      "\n",
      "At Epoch: 24\n",
      "Time since start: 393.5799310207367\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-125-cf7db5ce486f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m## h1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mclassModel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mclassTV_Train\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlr\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.01\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mbatchSize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlossType\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'ce'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mepochs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m30\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mnumConv\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mbatchNorm\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0moutKernels\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m30\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlinDim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m32\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-123-f183fd698ac0>\u001b[0m in \u001b[0;36mclassTV_Train\u001b[1;34m(lr, batchSize, lossType, epochs, numConv, batchNorm, outKernels, linDim)\u001b[0m\n\u001b[0;32m     51\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     52\u001b[0m             \u001b[1;31m# optimize\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 53\u001b[1;33m             \u001b[0mloss\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     54\u001b[0m             \u001b[0moptimizer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     55\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[0;32m    183\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    184\u001b[0m         \"\"\"\n\u001b[1;32m--> 185\u001b[1;33m         \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    186\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    187\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[0;32m    123\u001b[0m         \u001b[0mretain_graph\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    124\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 125\u001b[1;33m     Variable._execution_engine.run_backward(\n\u001b[0m\u001b[0;32m    126\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    127\u001b[0m         allow_unreachable=True)  # allow_unreachable flag\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "## h1\n",
    "classModel = classTV_Train(lr=0.01,batchSize=4,lossType='ce',epochs=22,numConv=4,batchNorm=False,outKernels=30,linDim=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Part 6: Best\"\"\"\n",
    "classTV_Train(lr=0.01,batchSize=4,lossType='ce',epochs=30,numConv=4,batchNorm=False,outKernels=30,linDim=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Part 6: BestSmall\"\"\"\n",
    "classTV_Train(lr=0.1,batchSize=4,lossType='mse',epochs=20,numConv=4,batchNorm=False,outKernels=10,linDim=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "list indices must be integers or slices, not tuple",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-121-b5e725104455>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m np.array([[8087,   35,  106,   84,  689,   66,  525,   21,  102,    5]\n\u001b[0m\u001b[0;32m      2\u001b[0m  \u001b[1;33m[\u001b[0m \u001b[1;36m166\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m7701\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m59\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m91\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m185\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m594\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m449\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m107\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m23\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m195\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m  \u001b[1;33m[\u001b[0m \u001b[1;36m332\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m61\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m7081\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m62\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m155\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m150\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m447\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m52\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m71\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m19\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m  \u001b[1;33m[\u001b[0m \u001b[1;36m254\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m44\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m23\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m7907\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m95\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m606\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m31\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m172\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m  \u001b[1;33m[\u001b[0m\u001b[1;36m1072\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m193\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m106\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m73\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m6882\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m117\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m502\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m29\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m164\u001b[0m\u001b[1;33m,\u001b[0m   \u001b[1;36m12\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not tuple"
     ]
    }
   ],
   "source": [
    "torch.save(classModel.state_dict(),\"./MyBest.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}