model_ear_project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_K0f_d4bma4F"
   },
   "source": [
    "## Using TensorBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HguM2dTkkc4D"
   },
   "outputs": [],
   "source": [
    "# !wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
    "# !unzip ngrok-stable-linux-amd64.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NMj5l0kJkizV"
   },
   "outputs": [],
   "source": [
    "# import os\n",
    "# LOG_DIR = 'runs'\n",
    "# os.makedirs(LOG_DIR, exist_ok=True)\n",
    "# get_ipython().system_raw(\n",
    "#     'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'\n",
    "#     .format(LOG_DIR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2_cQZHoikUcr"
   },
   "outputs": [],
   "source": [
    "# get_ipython().system_raw('./ngrok http 6006 &')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YACo-aXFkXfk"
   },
   "outputs": [],
   "source": [
    "# ! curl -s http://localhost:4040/api/tunnels | python3 -c \\\n",
    "#     \"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gVRAN-7vlFFS"
   },
   "outputs": [],
   "source": [
    "# from torch.utils.tensorboard import SummaryWriter\n",
    "# # load data from loader\n",
    "# images, labels = next(iter(train_dataloader))\n",
    "\n",
    "# images = images.to('cuda')\n",
    "# labels = labels.to('cuda')\n",
    "\n",
    "# tb = SummaryWriter()\n",
    "# tb.add_images(\"Image\", images)\n",
    "# tb.add_graph(net, images)\n",
    "# for i in range(1, 20):\n",
    "#     tb.add_scalar(\"Tag\", 10/i, i)\n",
    "    \n",
    "# tb.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WRmBtrj7miZi"
   },
   "source": [
    "## Declaring variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "joH_DyhPGtgv"
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function, division\n",
    "from pathlib import Path\n",
    "import os\n",
    "import torch\n",
    "import pandas as pd\n",
    "from skimage import io, transform\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import Dataset, DataLoader, random_split\n",
    "from torchvision import transforms, utils\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from IPython.core.debugger import set_trace\n",
    "import cv2\n",
    "from PIL import Image\n",
    "import random\n",
    "\n",
    "# Ignore warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "plt.ion()   # interactive mode\n",
    "\n",
    "# path = Path('drive/My Drive/Colab/Ear_Project')\n",
    "# if not os.path.exists('./dataset_original/dataset'):\n",
    "#    os.chdir(path)\n",
    "\n",
    "#reproducibility\n",
    "\n",
    "random.seed(420)\n",
    "torch.manual_seed(420)\n",
    "torch.cuda.manual_seed(420)\n",
    "np.random.seed(420)\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NG2NldVDwCo-"
   },
   "outputs": [],
   "source": [
    "class AutoCanny():\n",
    "  def __call__(self,sample):\n",
    "    img, label = sample['image'], sample['label']\n",
    "    img = np.asarray(img)\n",
    "    img = cv2.bilateralFilter(img, 4, 70, 110)\n",
    "    img = auto_canny(img)\n",
    "\n",
    "    return {'image': img.astype(np.float32) ,'label': label}\n",
    "\n",
    "class Padding():\n",
    "  def __call__(self,sample):\n",
    "    img, label = sample['image'], sample['label']\n",
    "    w, h = img.size[:2]\n",
    "    pad_width, pad_height = (max(0,h-w), max(0,w-h))\n",
    "\n",
    "    if pad_width % 2 == 0:\n",
    "      pad_right = pad_left = int(pad_width/2)\n",
    "    else:\n",
    "      pad_right = int(pad_width/2)\n",
    "      pad_left = int(pad_width/2) + 1\n",
    "\n",
    "    if pad_height % 2 == 0:\n",
    "      pad_top = pad_bottom = int(pad_height/2)\n",
    "    else:\n",
    "      pad_top = int(pad_height/2)\n",
    "      pad_bottom = int(pad_height/2) + 1\n",
    "\n",
    "    img = transforms.functional.pad(img, padding=(pad_left, pad_top, pad_right, pad_bottom))\n",
    "    \n",
    "\n",
    "    return {'image': img, 'label': label}\n",
    "\n",
    "class Resize():\n",
    "  def __call__(self, sample):\n",
    "    img, label = sample['image'], sample['label']\n",
    "    img = transforms.functional.resize(img, 96)\n",
    "    # set_trace()\n",
    "    # img = np.asarray(img)\n",
    "    # img = cv2.resize(img,(96,96),interpolation = cv2.INTER_AREA)\n",
    "    return {'image': img, 'label': label}\n",
    "\n",
    "class ToTensor(object):\n",
    "  \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\n",
    "\n",
    "  def __call__(self, sample):\n",
    "      img, label = (sample['image'], sample['label'])      \n",
    "      # swap color axis because\n",
    "      # numpy image: H x W x C\n",
    "      # torch image: C X H X W\n",
    "      img = img.reshape(96,96,1)\n",
    "      img = img.transpose((2, 0, 1))\n",
    "      return {'image': torch.from_numpy(img), 'label': torch.from_numpy(label)}\n",
    "\n",
    "class Normalize():\n",
    "  def __init__(self, mean, std, inplace=False):\n",
    "    self.mean = mean\n",
    "    self.std = std\n",
    "    self.inplace = inplace\n",
    "\n",
    "  def __call__(self, sample):\n",
    "    img, label = sample['image'], sample['label']\n",
    "\n",
    "    return transforms.functional.normalize(img, self.mean, self.std, self.inplace), label\n",
    "\n",
    "\n",
    "def auto_canny(image, sigma=0.6):\n",
    "\tv = np.median(image)\n",
    "\tlower = int(max(0, (1.0 - sigma) * v))\n",
    "\tupper = int(min(255, (1.0 + sigma) * v))\n",
    "\tedged = cv2.Canny(image, lower, upper)\n",
    "\n",
    "\treturn edged\n",
    "  #edged.astype(np.float32)\n",
    "\n",
    "\n",
    "def show_batch(batch):\n",
    "  images_batch, label = batch\n",
    "  grid = utils.make_grid(images_batch)\n",
    "  for img in images_batch:\n",
    "    print (img.shape)\n",
    "    print(f'Min pixel value: {torch.min(img)},\\nMax pixel value: {torch.max(img)}')\n",
    "  plt.imshow(grid.numpy().transpose(1,2,0))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JiCr9hPluqe8"
   },
   "outputs": [],
   "source": [
    "class CNNNet(nn.Module):\n",
    "  def __init__(self):\n",
    "    super(CNNNet, self).__init__()\n",
    "    self.features = nn.Sequential(\n",
    "      nn.Conv2d(1, 16, 3, padding=1),\n",
    "      nn.BatchNorm2d(16),\n",
    "      nn.ReLU(),\n",
    "      nn.MaxPool2d(2, 2),\n",
    "      nn.Conv2d(16, 16, kernel_size=3, padding=1),\n",
    "      nn.BatchNorm2d(16),\n",
    "      nn.ReLU(),\n",
    "      nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "    )\n",
    "    self.classifier = nn.Sequential(\n",
    "      nn.Linear(16*24*24, 1000),\n",
    "      nn.Linear(1000, 100),\n",
    "      nn.Linear(100, 8),\n",
    "    )\n",
    "  def forward(self, x):\n",
    "    x = self.features(x)\n",
    "    x = torch.flatten(x, 1)\n",
    "    x = self.classifier(x)\n",
    "    return x\n",
    "\n",
    "net = CNNNet().cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wR0Vq0TwWW3h"
   },
   "outputs": [],
   "source": [
    "def standard(img):\n",
    "  return (img - np.mean(img)) / np.std(img)\n",
    "\n",
    "class EarDataset(Dataset):\n",
    "\n",
    "  def __init__(self, pkl_file, root_dir, transform=None):\n",
    "    self.dataset = pd.read_pickle(pkl_file)\n",
    "    self.root_dir = root_dir\n",
    "    self.transform = transform\n",
    "      \n",
    "  def __len__(self):\n",
    "    return len(self.dataset)\n",
    "\n",
    "\n",
    "  def __getitem__(self, idx):\n",
    "    if torch.is_tensor(idx):\n",
    "      idx = idx.tolist()\n",
    "    \n",
    "    img_name = os.path.join(self.root_dir, self.dataset.iloc[idx, 0])\n",
    "    image = Image.open(img_name)\n",
    "    image = image.convert('L')\n",
    "    label = self.dataset.iloc[idx,1].astype(np.float32)\n",
    "    sample = {'image': image, 'label': label}\n",
    "\n",
    "\n",
    "    if self.transform:\n",
    "      sample = self.transform(sample)\n",
    "    return sample\n",
    "\n",
    "\n",
    "class DatasetFromSubset(Dataset):\n",
    "    def __init__(self, subset, transform=None):\n",
    "        self.subset = subset\n",
    "        self.transform = transform\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        img, label = self.subset[index]\n",
    "        if self.transform:\n",
    "            img, label = self.transform((img, label))\n",
    "        return img, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.subset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1RtH4dyTVkpD"
   },
   "outputs": [],
   "source": [
    "transform = transforms.Compose([Padding(),\n",
    "                                Resize(),\n",
    "                                AutoCanny(),\n",
    "                                ToTensor(),\n",
    "                                Normalize([0],[255]),\n",
    "                                ])\n",
    "\n",
    "pkl_file = 'dataset.pkl'\n",
    "\n",
    "root_dir = 'dataset'\n",
    "\n",
    "init_dataset = EarDataset(pkl_file=pkl_file, root_dir=root_dir, transform=None)\n",
    "\n",
    "total_len = len(init_dataset)\n",
    "\n",
    "lengths = [int(0.8*total_len), int(0.1*total_len), int(0.1*total_len)]\n",
    "\n",
    "train_subset, valid_subset, test_subset = random_split(init_dataset, lengths)\n",
    "\n",
    "train_dataset = DatasetFromSubset(train_subset, transform=None)\n",
    "valid_dataset = DatasetFromSubset(valid_subset, transform=None)\n",
    "test_dataset = DatasetFromSubset(test_subset, transform=None)\n",
    "\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "valid_dataloader = DataLoader(valid_dataset, batch_size=2)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 17212,
     "status": "ok",
     "timestamp": 1585171555869,
     "user": {
      "displayName": "Túlio Chiodi",
      "photoUrl": "",
      "userId": "17826402515266386932"
     },
     "user_tz": 180
    },
    "id": "8HJ6u47DU14W",
    "outputId": "6d2abcc4-3ff3-4dd2-e416-4cad2b562785"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[88, 11, 11]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 263
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 22437,
     "status": "ok",
     "timestamp": 1585171561104,
     "user": {
      "displayName": "Túlio Chiodi",
      "photoUrl": "",
      "userId": "17826402515266386932"
     },
     "user_tz": 180
    },
    "id": "5Kh6Kt1JQEup",
    "outputId": "88d221e3-7fc0-4a15-a8ab-c21dd1e056c9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 96, 96])\n",
      "Min pixel value: 0.0,\n",
      "Max pixel value: 1.0\n",
      "torch.Size([1, 96, 96])\n",
      "Min pixel value: 0.0,\n",
      "Max pixel value: 1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAADLCAYAAAB3Y8g9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAUjklEQVR4nO3df+wkd13H8efLOwryy7b8Sr2r9mpOlJhomwtW+RFCUWlFDhVMCYkXbXIxAQXR2CKJ4d/6A9TEQE6KVlOhWCC9mKiQWvzxByd3paUtR7mjQDl6tPyGoBErb//Y2XRuvzOz83vms/t6JJvvd2dndz77mc++9z2fz2dmFRGYmVl6vmfqApiZWTsO4GZmiXIANzNLlAO4mVmiHMDNzBLlAG5mlqhOAVzSSyXdL+m0pOv7KpSZma2ntvPAJe0CPgX8DHAG+Cjw6oj4RH/FMzOzMl0y8OcCpyPigYj4DvAe4GA/xTIzs3V2d3juHuDzuftngJ+seoIkn/ZpZtbclyPiGasLuwRwFSzbEaAlHQYOd9iOmdm2+1zRwi4B/Axwce7+XuCh1ZUi4ghwBJpn4Mv+eanou8Lmomo/FY2xbML+dNu0piKi9/bSpQ/8o8B+SfsknQdcAxztp1hmZrZO6ww8Ih6V9Drgn4FdwLsi4r7eSmbJK8s4NjUrNxtb62mErTbmLpSNVLafNjmAu21aUx27UE5ExIHVhV36wJNQ9QXlD193VY2yyfJNCOpmY9v4AA7lgaAsuDtwrNf3kVvdoF62rtk28rVQzMwStbEZeJ0+yiaZubO+YkPWi/ePWTVn4GZmidrYDLwLD7KVm8OPYHv/mC04AzczS5Qz8JqazJIoW3/Ommawc3t/nsVi22iWATyVkySqyjfH4D7HMg2p7iDoJr532w7uQjEzS9QsM/BN0DQ77zsLHGIbQ1xNbQqb8B7MwBm4mVmynIFPoO8B0aEz+jlMHTSznRzAZ6LtgGjRc4cKuO56sDnJt/NtbZvuQjEzS5Qz8AQ0zS4kdc7CtzWj2WZ9dMWNkRW7S+8xzsDNzBLlDHwD9DmIuXwtZzmbbaiB7/zRX9/ZuE/A2skBPFFDfgDLttV0HvimzBvfJG2DapOB9KJB9a7B1wOWxdyFYmaWKGfgiZniMHK5jXwmVWe7RYOpzp6mUXc/tL0AWFW76HL5X2fe1ZyBm5klyhl4QqbORooGqNaVo+okI2dUw6pb132Mp3RZv6hN+citHmfgZmaJcgaegDllrfn+8OXfJmUqyrzKHrd+zP266EVHaW4H9azNwCVdLOkOSScl3Sfp9dnyCyV9SNKp7O8Fwxd3u82pUUsqHNxs8xr52/K1PA+9var6K6rf/L6sWr/pra18O7BqdbpQHgV+JyJ+FLgCeK2k5wDXA7dHxH7g9uy+mZmNZG0XSkScBc5m/39L0klgD3AQeFG22k3Ah4HrBimlzVabgc11r7fk37Rsrqy7bYhphOu6Oobu+ptT1+JUGvWBS7oEuAw4BjwrC+5ExFlJzyx5zmHgcLdimpnZqtoBXNKTgfcBb4iIb9b9xouII8CR7DUG79RK5QeR60jlvRQNbOaXd33dVc7Md6rKRtdlql2mG1Zl9m2OAJps22oGcEmPYxG8b46I92eLH5Z0UZZ9XwQ8MlQht80QjbXroFKT9drOUOlanrnMqphSWdCsCtxdzpRcXb9sm02/5FfX38Z9WUedWSgCbgRORsRbcw8dBQ5l/x8Cbuu/eGZmVkY1rjL2fODfgXuA72aLf59FP/h7gR8AHgReFRFfXfNatdLALt+6m/CN3fU99D2/uu3rbfJ83rm0s6qjjqZl7GtQsM6RUNNum6nruQ8dPw8nIuLA6sI6s1D+Ayjb6pVtS2NmZt1Mdiam+yuLtemrHrouq65bsW57m5RBzVmd6Zer+mw3+f1cZxC17RUu7VyTBfCxBrxS0fbwdex6K/pwln0Aiy5KZP2oOtNyacw52vnPc1U7cOLWL1/MyswsUZNfzKrLoMsmaJuRzKWu+j4T05opquspzo70tMBpOAM3M0vU5Bl43jZ/S6f8Xlf3W9VjKb/PuehjXKGv/dC2LOvag9tLPc7AzcwSNasMfBu1vSbEnDOTFMqYurKpemNktF1OFPPss37NKoD7g5+2ul0p3r/j6msqZ59TAKvmgXvqaX3uQjEzS9SsMnCr5ux1uxUdodY9ap3LdXWKFGXebuf1OAM3M0uUM3Drnfu7N8+6/dg2U296IpKdywHczHao2zVTNLDZ9sxcB+7m3IViZpYoZ+A2qnyG5oyrnraDl23que2+8b6chjNwM7NEOQM3M6D5oHPZCTc+IWc8DuCJ80wPm8q2Xwp6DtyFYmaWqNlk4H0cbm1rNuqfqdou69r5XLLhqbe/DZyBm5klaja/Sm/rFU3BK/vFeGc/myHlfTmXI4FN5gzczCxRk2XgKfThpaboGstFj9vm6pKxV80qqduefEXBcdXOwCXtkvQxSf+Q3d8n6ZikU5JukXRe34UrC0Rt19sWknbcwPVk1ZbtI99GlveL2lR+/Xw7s/E06UJ5PXAyd/8G4G0RsR/4GnBtnwUzM7NqtQK4pL3AzwPvzO4LeDFwa7bKTcAr2hQg/y1e9m1ftM62dhGs1kmT5y05EzfY+dmD4qO3ss9V2ePOxsdTNwP/U+D3gO9m958GfD0iHs3unwH2FD1R0mFJxyUd71RSMzM7x9oALullwCMRcSK/uGDVwpQuIo5ExIGIOFDy+rV+DqqqD87f+PW4ntKWb+9ljzV5raV1mXb+9dcdBdu46sxCeR7wcklXA08AnsoiIz9f0u4sC98LPNSlIG0uBO9g1G7WwerMgqHq0ftnfE3qvM5MsKr1HcCntzYDj4g3RcTeiLgEuAb4l4h4DXAH8MpstUPAbYOV0szMduhyIs91wBslnWbRJ35j18KsHsatO1RL7TCu7DC0zXtwd4i1sa69rT5ep3vFpqMxA6CkWhtretJAKo2rqq7bvocuJ25MVX+p7bciY72H/P6t2mab37BcdyLOutcranspn/o/tI51c6JoHHE2VyPMq9Owytabm7ofmC4BIaWA6A94v9oE7tX1m362qrbpfTuuWQbwIqk1jLqZTNWpynUUDf5Wba9s26nV76Yb6ku5KnC7DaTHF7MyM0tUMhl4Stpc0KdLNuzMaXv1se/dftLlDNzMLFHOwHvkS2mWS2mg1bop6lt3f/swnIGbmSXKGXiPnFVYKtqMtdSZh170eNEMKx+R9cMB3GzG5jTFs05grjs3PD/1dS7vL0XuQjEzS5QzcBuUD5Xb6XqCV53Xb7pv+jwbeuj3ty2cgZuZJcoZ+BZzdry96ma+qV6DaFs4gM/EJgZTD1D1q89r1xTNzV6+dtW212n6/DZdOfYYd6GYmSXKGfjEphjEGXqbHphKU5szieucYbn6q/fWH2fgZmaJcgY+oT4yni7P7Tsb8vUu0tL2x63bXHe+jx8usZ0cwCfQ9APQ9Gewitaru802HzAH7vkrCtZN9nXXC7V53vcw3IViZpYoZ+AjqrrM5rrfKFxdp2p50S+P1/3NxKpMqelFjGx+mk5FHHP/unulOWfgZmaJcgY+krJMpm1fdZU2lwldfU6T13DGNJwhT3Spe3nYIbZd9NruH2/OGbiZWaKcgY+ozuyPdev1oY/sytlS2uqeSj9UW1yX/fuorp5aGbik8yXdKumTkk5K+ilJF0r6kKRT2d8Lhi5s6lYHF5f3hwje+ddevUk659blPfiDNr5l8B3yS7RN22jzuqttye2pmbpdKH8G/FNE/Ajw48BJ4Hrg9ojYD9ye3Tczs5Fo3be4pKcCdwOXRm5lSfcDL4qIs5IuAj4cEc9e81o+7mb46VJDZcjOvB8z5pS3qqmmU3Rx9L2dooH8TWxfHd/XiYg4sLqwTgZ+KfAl4K8kfUzSOyU9CXhWRJzNCnYWeGbRkyUdlnRc0vG2JTczs53qBPDdwOXA2yPiMuDbNOguiYgjEXGg6NtjW/XZ11fUxz3UNvp+XatnWedD93sXqRpLKWt7Np46AfwMcCYijmX3b2UR0B/Ouk7I/j4yTBEtr2hAcqntwOS6beVf3+ZlrMHMuremwXyqL6ZNsTaAR8QXgc9LWvZvXwl8AjgKHMqWHQJuG6SEZmZWqO488N8EbpZ0HvAA8Gssgv97JV0LPAi8apgibrYmZ8OVrTd0ZuzMe37GOnux6WBm1RTBstd3+2qvVgCPiLuAoj7sK/stjpmZ1eUzMSfW5DrNY/YTuk9yO5WdiVljunHlMrenYTiAz0TTy3wOxYOW81XURooSgD63VXZ/abndddtveulaq8cXszIzS5QzcAP8s2jWTh9nUbrttecM3MwsUc7AB9Jnn+SYfYPOfuZv3UB3233YRzur+wMUdafIWjVn4GZmiXIGPoB8FlQ3E6+aRjj0SRse/U9fvo00Pfrre+ZR1dTYsnWtHQfwHlUFwnWHtkVTxFK97KyNp+jLvukX8hhndY7VpreNu1DMzBLlDHwAq1cIhPLspirrGSPzHnI7Npw6WXOX7rvV7XQpY1+vZzs5AzczS5Qz8AmV/ZzUaubUV9+kM+/NVfSDG/nT3Ltc7dLmywF8JHUHl/Lr9RFw/SHdbFXBet3MFLeD9LkLxcwsUc7Ae9DlovdtHm9Spj5f0+arKtsuOqpze9gMzsDNzBLlDHwD+QSd7VWWbRf1leefY2lyAO/B1GeZeaDS8uoMbK4+vvqYpcFdKGZmiXIG3oM+5mnXnWJY9TxnUJZXdxrhuvniNl/OwM3MEuUMvAdVA0RFuvRZu7/bmio7OazuCT9z4CPNYs7AzcwSVSuAS/ptSfdJulfSuyU9QdI+SccknZJ0i6Tzhi7s3C2na632M9a59bEtszJF7S2fcS/XWVp9bA7c3ndaG8Al7QF+CzgQET8G7AKuAW4A3hYR+4GvAdcOWdDUDNHYloNMbsTWVVmwXm1fUwfyou1PXaY5qduFshv4Xkm7gScCZ4EXA7dmj98EvKL/4pmZWZm1ATwivgD8MfAgi8D9DeAE8PWIeDRb7QywZ6hCmln/irLtOo+Noap7xx5TpwvlAuAgsA/4fuBJwFUFqxbuYUmHJR2XdLxLQc3M7Fx1phG+BPhMRHwJQNL7gZ8Gzpe0O8vC9wIPFT05Io4AR7LnuuOqA2chNoR1VzJcfWz1eX1z5l1fnT7wB4ErJD1Ri9q8EvgEcAfwymydQ8BtwxTRzMZQNXhZNOupz1+Kyt/y2ytazwP5j6nTB36MxWDlncA92XOOANcBb5R0GngacOOA5TQzsxUac3DCXSi2KeZ6xmJf6naXtD0zuOnzNqFbpeO1Zk5ExIHVhT4T08wsUb4WipntUPcHIOr+2n3Z66+zCZn3kBzAzaxUmx+AaBtofaG25tyFYmaWKGfgZlZL0bS+OusVcbbdD2fgZmaJcgZuZq00mVpY97nWjDNwM7NEOQM3s145ux6PM3Azs0Q5gJuZJcoB3MwsUQ7gZmaJcgA3M0uUA7iZWaIcwM3MEuUAbmaWKAdwM7NEOYCbmSXKAdzMLFEO4GZmiXIANzNLlAO4mVmiHMDNzBLlAG5mlij/oINZC/7RAmtqiDbjDNzMLFEO4GZmiRq7C+XLwLezv3P3dFzOPqVSTkinrC5n/+Za1h8sWqiIGLUUko5HxIFRN9qCy9mvVMoJ6ZTV5exfSmUFd6GYmSXLAdzMLFFTBPAjE2yzDZezX6mUE9Ipq8vZv5TKOn4fuJmZ9cNdKGZmiRotgEt6qaT7JZ2WdP1Y211H0sWS7pB0UtJ9kl6fLX+LpC9Iuiu7XT11WQEkfVbSPVmZjmfLLpT0IUmnsr8XTFzGZ+fq7S5J35T0hjnUqaR3SXpE0r25ZYX1p4U/z9rsxyVdPoOy/pGkT2bl+YCk87Pll0j671zdvmPicpbua0lvyur0fkk/N3E5b8mV8bOS7sqWT1afjUTE4DdgF/Bp4FLgPOBu4DljbLtG2S4CLs/+fwrwKeA5wFuA3526fAXl/Szw9JVlfwhcn/1/PXDD1OVc2fdfZDGPdfI6BV4IXA7cu67+gKuBfwQEXAEcm0FZfxbYnf1/Q66sl+TXm0E5C/d19tm6G3g8sC+LC7umKufK438C/MHU9dnkNlYG/lzgdEQ8EBHfAd4DHBxp25Ui4mxE3Jn9/y3gJLBn2lI1dhC4Kfv/JuAVE5Zl1ZXApyPic1MXBCAi/g346srisvo7CPxNLHwEOF/SReOUtLisEfHBiHg0u/sRYO9Y5SlTUqdlDgLviYj/iYjPAKdZxIfBVZVTiwuV/Arw7jHK0pexAvge4PO5+2eYYZCUdAlwGXAsW/S67FD1XVN3S+QE8EFJJyQdzpY9KyLOwuILCXjmZKXb6RrO/VDMsU7L6m/u7fbXWRwhLO2T9DFJ/yrpBVMVKqdoX8+1Tl8APBwRp3LL5lafO4wVwIsuwzWr6S+Sngy8D3hDRHwTeDvwQ8BPAGdZHF7NwfMi4nLgKuC1kl44dYHKSDoPeDnw99miudZpmdm2W0lvBh4Fbs4WnQV+ICIuA94I/J2kp05VPsr39Vzr9NWcm2jMrT4LjRXAzwAX5+7vBR4aadtrSXoci+B9c0S8HyAiHo6I/4uI7wJ/yUiHeetExEPZ30eAD7Ao18PLQ/vs7yPTlfAcVwF3RsTDMN86pbz+ZtluJR0CXga8JrIO26xL4ivZ/ydY9C3/8FRlrNjXs6tTSbuBXwJuWS6bW32WGSuAfxTYL2lflpVdAxwdaduVsr6vG4GTEfHW3PJ8X+cvAveuPndskp4k6SnL/1kMaN3Loi4PZasdAm6bpoQ7nJPVzLFOM2X1dxT41Ww2yhXAN5ZdLVOR9FLgOuDlEfFfueXPkLQr+/9SYD/wwDSlrNzXR4FrJD1e0j4W5fzPscu34iXAJyPizHLB3Oqz1FijpSxG9D/F4pvszVOP3ubK9XwWh3AfB+7KblcDfwvcky0/Clw0g7JeymIE/27gvmU9Ak8DbgdOZX8vnEFZnwh8Bfi+3LLJ65TFF8pZ4H9ZZIPXltUfi8P9v8ja7D3AgRmU9TSLPuRlW31Htu4vZ23ibuBO4BcmLmfpvgbenNXp/cBVU5YzW/7XwG+srDtZfTa5+UxMM7NE+UxMM7NEOYCbmSXKAdzMLFEO4GZmiXIANzNLlAO4mVmiHMDNzBLlAG5mlqj/B8g227b6dGXlAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "batch = next(iter(train_dataloader))\n",
    "show_batch(batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 96, 96])\n",
      "Min pixel value: 0.0,\n",
      "Max pixel value: 1.0\n",
      "torch.Size([1, 96, 96])\n",
      "Min pixel value: 0.0,\n",
      "Max pixel value: 1.0\n"
     ]
    },
    {
     "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": [
    "batch = next(iter(valid_dataloader))\n",
    "show_batch(batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 96, 96])\n",
      "Min pixel value: 0.0,\n",
      "Max pixel value: 1.0\n",
      "torch.Size([1, 96, 96])\n",
      "Min pixel value: 0.0,\n",
      "Max pixel value: 1.0\n"
     ]
    },
    {
     "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": [
    "batch = next(iter(test_dataloader))\n",
    "show_batch(batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xRu6_H3hObME"
   },
   "outputs": [],
   "source": [
    "# iterator = iter(valid_dataloader)\n",
    "\n",
    "# for a in iterator:\n",
    "#   show_batch(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KHEMwulgbSBE"
   },
   "outputs": [],
   "source": [
    "def weight_reset(m):\n",
    "    if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\n",
    "        m.reset_parameters()\n",
    "\n",
    "\n",
    "def train(model, optimizer, loss_fn, train_loader, val_loader, epochs=20, device=\"cpu\"):\n",
    "  model.apply(weight_reset)\n",
    "  for epoch in range(epochs):\n",
    "    training_loss = 0.0\n",
    "    valid_loss = 0.0\n",
    "    model.train()\n",
    "    for batch in train_loader:\n",
    "      optimizer.zero_grad()\n",
    "      inputs, target = batch\n",
    "      inputs = inputs.to(device)\n",
    "      target = target.to(device)\n",
    "      output = model(inputs)\n",
    "      loss = loss_fn(output, target)\n",
    "      loss.backward()\n",
    "      optimizer.step()\n",
    "      training_loss += loss.item()\n",
    "      train_error = torch.dist(target, output)\n",
    "    training_loss /= len(train_loader)\n",
    "\n",
    "    model.eval()\n",
    "    num_correct = 0\n",
    "    num_examples = 0\n",
    "    for batch in val_loader:\n",
    "      inputs, targets = batch\n",
    "      inputs = inputs.to(device)\n",
    "      output = model(inputs)\n",
    "      targets = targets.to(device)\n",
    "      loss = loss_fn(output,targets)\n",
    "      valid_loss += loss.item()\n",
    "      val_error = torch.dist(targets, output)\n",
    "    valid_loss /= len(val_loader)\n",
    "\n",
    "    print(f'Epoch: {epoch}, Training Loss: {training_loss}, Validation Loss: {valid_loss}, Train Error = {train_error}, Validation Error = {val_error}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 119007,
     "status": "ok",
     "timestamp": 1585171657693,
     "user": {
      "displayName": "Túlio Chiodi",
      "photoUrl": "",
      "userId": "17826402515266386932"
     },
     "user_tz": 180
    },
    "id": "x1ARIasobaWh",
    "outputId": "eab38a01-9cd4-47b5-9c8f-9a114730d533"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Training Loss: 0.8349667582660913, Validation Loss: 0.12071205551425616, Train Error = 2.2499048709869385, Validation Error = 0.8921821117401123\n",
      "Epoch: 1, Training Loss: 0.16216742128811099, Validation Loss: 0.15276510020097098, Train Error = 1.2590116262435913, Validation Error = 1.0724183320999146\n",
      "Epoch: 2, Training Loss: 0.09266436112705957, Validation Loss: 0.13117851316928864, Train Error = 0.6430891156196594, Validation Error = 1.105743408203125\n",
      "Epoch: 3, Training Loss: 0.07225791855969212, Validation Loss: 0.17984257265925407, Train Error = 1.1049704551696777, Validation Error = 1.4526392221450806\n",
      "Epoch: 4, Training Loss: 0.06846877941015092, Validation Loss: 0.18465964992841086, Train Error = 1.128463864326477, Validation Error = 1.4940420389175415\n",
      "Epoch: 5, Training Loss: 0.07494380358945239, Validation Loss: 0.16388286463916302, Train Error = 1.3550530672073364, Validation Error = 1.4434536695480347\n",
      "Epoch: 6, Training Loss: 0.07097728753631766, Validation Loss: 0.2359229400753975, Train Error = 1.0569521188735962, Validation Error = 1.6495486497879028\n",
      "Epoch: 7, Training Loss: 0.07246672243557194, Validation Loss: 0.16747562463084856, Train Error = 1.3411505222320557, Validation Error = 1.4357562065124512\n",
      "Epoch: 8, Training Loss: 0.05045134577349844, Validation Loss: 0.20497065782546997, Train Error = 1.0201597213745117, Validation Error = 1.5640190839767456\n",
      "Epoch: 9, Training Loss: 0.038951681376519526, Validation Loss: 0.166240893304348, Train Error = 0.5118392705917358, Validation Error = 1.5032356977462769\n"
     ]
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(net.parameters(), lr=0.00005)\n",
    "\n",
    "train(model=net, optimizer=optimizer, loss_fn=criterion,\n",
    "      train_loader=train_dataloader, val_loader=valid_dataloader,\n",
    "      epochs=10, device=\"cuda\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TSHgnF6lqbU4"
   },
   "source": [
    "Epoch: 9, Training Loss: 0.038951681376519526, Validation Loss: 0.166240893304348, Train Error = 0.5118392705917358, Validation Error = 1.5032356977462769\n",
    "\n",
    "Epoch: 49, Training Loss: 0.006912451507311992, Validation Loss: 0.19517305245002112, Train Error = 0.3576761782169342, Validation Error = 1.1172915697097778\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "K1FsS8f1Xwxg"
   },
   "outputs": [],
   "source": [
    "# net.eval()\n",
    "# prediction = [net(batch[0].to('cuda')) for batch in test_dataloader]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2576,
     "status": "ok",
     "timestamp": 1585167898069,
     "user": {
      "displayName": "Túlio Chiodi",
      "photoUrl": "",
      "userId": "17826402515266386932"
     },
     "user_tz": 180
    },
    "id": "yJklW1RsXiyK",
    "outputId": "895b89a2-eb78-4efc-aaca-bb972194715f"
   },
   "outputs": [],
   "source": [
    "# for item in test_subset:\n",
    "#   print (item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "b8wXrDQlSidZ"
   },
   "outputs": [],
   "source": [
    "# ground_truth = [batch[1].to('cuda') for batch in test_dataloader]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1755,
     "status": "error",
     "timestamp": 1585167482893,
     "user": {
      "displayName": "Túlio Chiodi",
      "photoUrl": "",
      "userId": "17826402515266386932"
     },
     "user_tz": 180
    },
    "id": "jlESmeWQVD2X",
    "outputId": "760736d4-ec29-47f4-c6dd-5ffc33a5ea5b"
   },
   "outputs": [],
   "source": [
    "# ground_truth = []\n",
    "\n",
    "# for batch in test_dataloader:\n",
    "#   for sample in batch:\n",
    "#     print(sample[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GKp29oE-Qhzx"
   },
   "outputs": [],
   "source": [
    "# net.eval()\n",
    "# prediction = [net(batch[0].to('cuda')) for batch in test_dataloader]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "w261AUI9Tqhk"
   },
   "outputs": [],
   "source": [
    "# for gt, pred in zip(ground_truth, prediction):\n",
    "#   print (gt.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 380
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1645,
     "status": "ok",
     "timestamp": 1585166850023,
     "user": {
      "displayName": "Túlio Chiodi",
      "photoUrl": "",
      "userId": "17826402515266386932"
     },
     "user_tz": 180
    },
    "id": "ZAkEKJlDTNmO",
    "outputId": "8142e9ae-69b8-48b6-a338-2e4cae96b0e5"
   },
   "outputs": [],
   "source": [
    "# prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mzvxDAtB3OIM"
   },
   "outputs": [],
   "source": [
    "# path = 'testset/0051_left.jpg'\n",
    "# target = torch.tensor([1.7321, 0.82316, 1.7177, 1.3736, 5.94, 2.8194, 0.57672, 1.0697]).to('cuda')\n",
    "# image = Image.open(path)\n",
    "# sample_pred = {'image': image, 'label': np.random.randn(8)}\n",
    "# transformed_sample = transform(sample_pred)\n",
    "# print_img = transformed_sample[0]\n",
    "# img = transformed_sample[0].unsqueeze(0).to('cuda')\n",
    "# print(torch.max(img))\n",
    "# prediction = net(img)\n",
    "# error = torch.dist(target, prediction)\n",
    "# print(f'prediction: {prediction}.\\nGround truth: {target}.')\n",
    "# print(error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jbWRzhUXAgN0"
   },
   "outputs": [],
   "source": [
    "# error = [torch.dist(ground_truth, prediction)]\n",
    "# erro = abs(target-prediction)\n",
    "# erro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CP3_NNhrDoeE"
   },
   "outputs": [],
   "source": [
    "# erro.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0gSIu55FWR-k"
   },
   "source": [
    "\n",
    "Previsão: 1.8504, 0.4400, 1.5174, 1.2913, 6.1952, 2.9311, 0.4214, 1.0045\n",
    "\n",
    "Valor real: 1.7321\t0.82316\t1.7177\t1.3736\t5.94\t2.8194\t0.57672\t1.0697"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TkdZG8CbFY1V"
   },
   "source": [
    "## Treinando vários modelos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "68K1POGsFbB8"
   },
   "outputs": [],
   "source": [
    "# batch1 = CNNNet().cuda()\n",
    "# optimizer1 = optim.Adam(batch1.parameters(), lr=0.00005)\n",
    "\n",
    "# train_dataloader1 = DataLoader(train_dataset, batch_size=1, shuffle=True)\n",
    "# val_dataloader1 = DataLoader(test_dataset, batch_size=1)\n",
    "\n",
    "# train(model=batch1, optimizer=optimizer1, loss_fn=criterion,\n",
    "#       train_loader=train_dataloader1, val_loader=val_dataloader1,\n",
    "#       epochs=50, device=\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ct5icbb8F7EU"
   },
   "outputs": [],
   "source": [
    "# batch2 = CNNNet().cuda()\n",
    "# optimizer2 = optim.Adam(batch2.parameters(), lr=0.00005)\n",
    "\n",
    "# train_dataloader2 = DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "# val_dataloader2 = DataLoader(test_dataset, batch_size=2)\n",
    "\n",
    "# train(model=batch2, optimizer=optimizer2, loss_fn=criterion,\n",
    "#       train_loader=train_dataloader2, val_loader=val_dataloader2,\n",
    "#       epochs=50, device=\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jk2A91WOF7UQ"
   },
   "outputs": [],
   "source": [
    "# batch4 = CNNNet().cuda()\n",
    "# optimizer4 = optim.Adam(batch4.parameters(), lr=0.00005)\n",
    "\n",
    "# train_dataloader4 = DataLoader(train_dataset, batch_size=4, shuffle=True)\n",
    "# val_dataloader4 = DataLoader(test_dataset, batch_size=4)\n",
    "\n",
    "# train(model=batch4, optimizer=optimizer4, loss_fn=criterion,\n",
    "#       train_loader=train_dataloader4, val_loader=val_dataloader4,\n",
    "#       epochs=50, device=\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CB8WzNFwF7qQ"
   },
   "outputs": [],
   "source": [
    "# batch8 = CNNNet().cuda()\n",
    "# optimizer8 = optim.Adam(batch8.parameters(), lr=0.00005)\n",
    "\n",
    "# train_dataloader8 = DataLoader(train_dataset, batch_size=8, shuffle=True)\n",
    "# val_dataloader8 = DataLoader(test_dataset, batch_size=8)\n",
    "\n",
    "# train(model=batch8, optimizer=optimizer8, loss_fn=criterion,\n",
    "#       train_loader=train_dataloader8, val_loader=val_dataloader8,\n",
    "#       epochs=50, device=\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "guElSB1LF7zw"
   },
   "outputs": [],
   "source": [
    "# batch16 = CNNNet().cuda()\n",
    "# optimizer16 = optim.Adam(batch16.parameters(), lr=0.00005)\n",
    "\n",
    "# train_dataloader16 = DataLoader(train_dataset, batch_size=16, shuffle=True)\n",
    "# val_dataloader16 = DataLoader(test_dataset, batch_size=16)\n",
    "\n",
    "# train(model=batch16, optimizer=optimizer16, loss_fn=criterion,\n",
    "#       train_loader=train_dataloader16, val_loader=val_dataloader16,\n",
    "#       epochs=50, device=\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9hu6wx1ZF78p"
   },
   "outputs": [],
   "source": [
    "# batch32 = CNNNet().cuda()\n",
    "# optimizer32 = optim.Adam(batch32.parameters(), lr=0.00005)\n",
    "\n",
    "# train_dataloader32 = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
    "# val_dataloader32 = DataLoader(test_dataset, batch_size=32)\n",
    "\n",
    "# train(model=batch32, optimizer=optimizer32, loss_fn=criterion,\n",
    "#       train_loader=train_dataloader32, val_loader=val_dataloader32,\n",
    "#       epochs=200, device=\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zxIWZDJTG01S"
   },
   "outputs": [],
   "source": [
    "# prediction1 = batch1(img)\n",
    "# prediction2 = batch2(img)\n",
    "# prediction4 = batch4(img)\n",
    "# prediction8 = batch8(img)\n",
    "# prediction16 = batch16(img)\n",
    "# prediction32 = batch32(img)\n",
    "\n",
    "# erro1 = abs(target-prediction1)\n",
    "# erro2 = abs(target-prediction2)\n",
    "# erro4 = abs(target-prediction4)\n",
    "# erro8 = abs(target-prediction8)\n",
    "# erro16 = abs(target-prediction16)\n",
    "# erro32 = abs(target-prediction32)\n",
    "\n",
    "# print(f'Vetor de erros:\\n1: {erro1}.\\n2: {erro2}.\\n4: {erro4}.\\n8: {erro8}.\\n16: {erro16}.\\n32: {erro32}.')\n",
    "# print(f'Valores absolutos:\\n1: {erro1.sum()}.\\n2: {erro2.sum()}.\\n4: {erro4.sum()}.\\n8: {erro8.sum()}.\\n16: {erro16.sum()}.\\n32: {erro32.sum()}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xJRkPz9XsOo0"
   },
   "outputs": [],
   "source": [
    "# !pip install onnx\n",
    "# !pip install onnxruntime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "x0riSBZ1buT6"
   },
   "outputs": [],
   "source": [
    "# import io\n",
    "# import numpy as np\n",
    "\n",
    "# from torch import nn\n",
    "# import torch.utils.model_zoo as model_zoo\n",
    "# import torch.onnx\n",
    "\n",
    "# batch32 = CNNNet().cuda()\n",
    "\n",
    "# batch32.eval()\n",
    "\n",
    "# x = torch.randn(32, 1, 96, 96, requires_grad=True).to('cuda')\n",
    "# torch_out = batch32(x)\n",
    "\n",
    "# # torch.onnx.export(\n",
    "# #     batch32,\n",
    "# #     x,\n",
    "# #     'model.onnx',\n",
    "# #     export_params=True,\n",
    "# # )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HEP2Lq5jsxGt"
   },
   "outputs": [],
   "source": [
    "# import onnx\n",
    "\n",
    "# onnx_model = onnx.load(\"model.onnx\")\n",
    "# onnx.checker.check_model(onnx_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B2aISEYVsz9v"
   },
   "outputs": [],
   "source": [
    "# import onnxruntime\n",
    "\n",
    "# ort_session = onnxruntime.InferenceSession(\"model.onnx\")\n",
    "\n",
    "# def to_numpy(tensor):\n",
    "#     return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()\n",
    "\n",
    "# # compute ONNX Runtime output prediction\n",
    "# ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(x)}\n",
    "# ort_outs = ort_session.run(None, ort_inputs)\n",
    "\n",
    "# # compare ONNX Runtime and PyTorch results\n",
    "# np.testing.assert_allclose(to_numpy(torch_out), ort_outs[0], rtol=1e-03, atol=1e-05)\n",
    "\n",
    "# print(\"Exported model has been tested with ONNXRuntime, and the result looks good!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V75bCZYItEd3"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "authorship_tag": "ABX9TyOOl7/hQnSCpjawR4AGefP+",
   "collapsed_sections": [
    "_K0f_d4bma4F"
   ],
   "mount_file_id": "1leJPjjHUsi01_S2ysSHs9v0WzzgewisD",
   "name": "model_ear_project.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Ear Project",
   "language": "python",
   "name": "ear_project"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}