50_small_norb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.10",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "50-small-norb.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jqyreHeQGYj5"
      },
      "source": [
        "This code demonstrates how to load small NORB database into numpy array, it appeared to be non trivial task, because \".mat\" files is not a plain text as MNIST \".mat\".\n",
        "Code originated from\n",
        "https://jessicastringham.net/2018/05/03/smallnorb/\n",
        "in its turn, it based on\n",
        "https://github.com/ndrplz/small_norb\n",
        "I just adopted it for Kaggle."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:06.630875Z",
          "iopub.execute_input": "2021-06-02T07:31:06.631384Z",
          "iopub.status.idle": "2021-06-02T07:31:06.658460Z",
          "shell.execute_reply.started": "2021-06-02T07:31:06.631213Z",
          "shell.execute_reply": "2021-06-02T07:31:06.657527Z"
        },
        "trusted": true,
        "id": "7FlDC-_TGYj9",
        "outputId": "2675db71-e9b9-4138-e0a4-4e8af0da79fa"
      },
      "source": [
        "#show files\n",
        "import os\n",
        "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
        "    for filename in filenames:\n",
        "        print(os.path.join(dirname, filename))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/kaggle/input/the-small-norb-dataset-v10/smallnorb-5x46789x9x18x6x2x96x96-training-info.mat\n",
            "/kaggle/input/the-small-norb-dataset-v10/smallnorb-5x01235x9x18x6x2x96x96-testing-info.mat\n",
            "/kaggle/input/the-small-norb-dataset-v10/smallnorb-5x01235x9x18x6x2x96x96-testing-cat.mat\n",
            "/kaggle/input/the-small-norb-dataset-v10/smallnorb-5x01235x9x18x6x2x96x96-testing-dat.mat\n",
            "/kaggle/input/the-small-norb-dataset-v10/smallnorb-5x46789x9x18x6x2x96x96-training-dat.mat\n",
            "/kaggle/input/the-small-norb-dataset-v10/smallnorb-5x46789x9x18x6x2x96x96-training-cat.mat\n",
            "/kaggle/input/checkpoints/model100.0resnet18pretrained.pt\n",
            "/kaggle/input/checkpoints/finalmobilenet50.pt\n",
            "/kaggle/input/checkpoints/model99.98mobilenet50.pt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:06.659916Z",
          "iopub.execute_input": "2021-06-02T07:31:06.660245Z",
          "iopub.status.idle": "2021-06-02T07:31:10.160316Z",
          "shell.execute_reply.started": "2021-06-02T07:31:06.660211Z",
          "shell.execute_reply": "2021-06-02T07:31:10.159464Z"
        },
        "trusted": true,
        "id": "bA-HXSo2GYj-"
      },
      "source": [
        "import os\n",
        "import cv2\n",
        "import wandb\n",
        "import time\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "import torchvision\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import albumentations as A\n",
        "import torch.optim as optim\n",
        "from torchvision import transforms\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from pathlib import Path\n",
        "from albumentations.pytorch import ToTensorV2\n",
        "import torch.nn.functional as F\n",
        "from tqdm.auto import tqdm"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:10.163669Z",
          "iopub.execute_input": "2021-06-02T07:31:10.163927Z",
          "iopub.status.idle": "2021-06-02T07:31:10.183792Z",
          "shell.execute_reply.started": "2021-06-02T07:31:10.163902Z",
          "shell.execute_reply": "2021-06-02T07:31:10.182987Z"
        },
        "trusted": true,
        "id": "5NTdmiJKGYj_",
        "outputId": "a6caa34f-49be-49b5-80c4-cefe84803e18"
      },
      "source": [
        "torch.manual_seed(42)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7efcefd9a2f0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:10.188235Z",
          "iopub.execute_input": "2021-06-02T07:31:10.188542Z",
          "iopub.status.idle": "2021-06-02T07:31:17.462374Z",
          "shell.execute_reply.started": "2021-06-02T07:31:10.188507Z",
          "shell.execute_reply": "2021-06-02T07:31:17.461499Z"
        },
        "trusted": true,
        "id": "FoHY1q6SGYkA",
        "outputId": "2eb5e1b5-434d-483a-8d55-82f18f77772d"
      },
      "source": [
        "# https://jessicastringham.net/2018/05/03/smallnorb/\n",
        "import numpy as np\n",
        "import struct\n",
        "\n",
        "DATA_FOLDER = \"/kaggle/input/the-small-norb-dataset-v10/\"\n",
        "\n",
        "PREFIXES = {\n",
        "    'train': 'smallnorb-5x46789x9x18x6x2x96x96-training-',\n",
        "    'test': 'smallnorb-5x01235x9x18x6x2x96x96-testing-',\n",
        "}\n",
        "\n",
        "FILE_TYPES = ['info', 'cat', 'dat']\n",
        "\n",
        "# helper function to read int from file\n",
        "def read_int(f):\n",
        "    num, = struct.unpack('i', f.read(4))\n",
        "    return num\n",
        "\n",
        "\n",
        "# From https://cs.nyu.edu/~ylclab/data/norb-v1.0-small/ \n",
        "# \"The magic number encodes the element type of the matrix\"\n",
        "# Note: I only copied over the ones I needed for these files.\n",
        "map_magic_number_to_data_type = {\n",
        "    '1e3d4c55': np.uint8,\n",
        "    '1e3d4c54': np.int32,\n",
        "}\n",
        "\n",
        "loaded_data = {}\n",
        "\n",
        "for dataset, prefix in PREFIXES.items():\n",
        "    for filetype in FILE_TYPES:\n",
        "        filename = prefix + filetype + \".mat\"\n",
        "        print('Reading {}'.format(filename))\n",
        "        \n",
        "        file_loc = os.path.join(DATA_FOLDER, filename)\n",
        "        with open( file_loc, 'rb') as f:\n",
        "            # Read the magic_num, convert it to hexadecimal, and look up the data_type\n",
        "            raw_magic_num = read_int(f)\n",
        "            magic_num = format(raw_magic_num, '02x')\n",
        "            data_type = map_magic_number_to_data_type[magic_num]\n",
        "            print('dtype', data_type)\n",
        "\n",
        "            # Read how many dimensions to expect\n",
        "            ndim = read_int(f)\n",
        "            \n",
        "            # Read at least 3 ints, or however many ndim there are\n",
        "            shape = [\n",
        "                read_int(f)\n",
        "                for i in range(max(ndim, 3))\n",
        "            ]   \n",
        "            # But in case ndims < 3, take at most n_dim elements\n",
        "            shape = shape[:ndim]\n",
        "            print('shape', shape)\n",
        "    \n",
        "            # Now load the actual data!\n",
        "            loaded_data[(dataset, filetype)] = np.fromfile(\n",
        "                f, \n",
        "                dtype=data_type, \n",
        "                count=np.prod(shape)\n",
        "            ).reshape(shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading smallnorb-5x46789x9x18x6x2x96x96-training-info.mat\n",
            "dtype <class 'numpy.int32'>\n",
            "shape [24300, 4]\n",
            "Reading smallnorb-5x46789x9x18x6x2x96x96-training-cat.mat\n",
            "dtype <class 'numpy.int32'>\n",
            "shape [24300]\n",
            "Reading smallnorb-5x46789x9x18x6x2x96x96-training-dat.mat\n",
            "dtype <class 'numpy.uint8'>\n",
            "shape [24300, 2, 96, 96]\n",
            "Reading smallnorb-5x01235x9x18x6x2x96x96-testing-info.mat\n",
            "dtype <class 'numpy.int32'>\n",
            "shape [24300, 4]\n",
            "Reading smallnorb-5x01235x9x18x6x2x96x96-testing-cat.mat\n",
            "dtype <class 'numpy.int32'>\n",
            "shape [24300]\n",
            "Reading smallnorb-5x01235x9x18x6x2x96x96-testing-dat.mat\n",
            "dtype <class 'numpy.uint8'>\n",
            "shape [24300, 2, 96, 96]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:17.463738Z",
          "iopub.execute_input": "2021-06-02T07:31:17.464078Z",
          "iopub.status.idle": "2021-06-02T07:31:17.471445Z",
          "shell.execute_reply.started": "2021-06-02T07:31:17.464042Z",
          "shell.execute_reply": "2021-06-02T07:31:17.470703Z"
        },
        "trusted": true,
        "id": "ySc18-3oGYkB"
      },
      "source": [
        "transform = A.Compose([\n",
        "    A.RandomBrightnessContrast(p=0.6),    \n",
        "    A.CenterCrop(width=69, height=69), \n",
        "    A.Resize(width=96,height=96),\n",
        "    A.CLAHE(p=0.5),\n",
        "    A.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n",
        "    ])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:17.472981Z",
          "iopub.execute_input": "2021-06-02T07:31:17.473530Z",
          "iopub.status.idle": "2021-06-02T07:31:17.761065Z",
          "shell.execute_reply.started": "2021-06-02T07:31:17.473490Z",
          "shell.execute_reply": "2021-06-02T07:31:17.760274Z"
        },
        "trusted": true,
        "id": "istfHaFFGYkB"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import kornia\n",
        "\n",
        "from kornia.filters.kernels import (\n",
        "    get_spatial_gradient_kernel2d, get_spatial_gradient_kernel3d, normalize_kernel2d\n",
        ")\n",
        "\n",
        "\n",
        "def spatial_gradient(input: torch.Tensor,\n",
        "                     mode: str = 'sobel',\n",
        "                     order: int = 1,\n",
        "                     normalized: bool = True) -> torch.Tensor:\n",
        "    r\"\"\"Computes the first order image derivative in both x and y using a Sobel\n",
        "    operator.\n",
        "\n",
        "    Args:\n",
        "        input (torch.Tensor): input image tensor with shape :math:`(B, C, H, W)`.\n",
        "        mode (str): derivatives modality, can be: `sobel` or `diff`. Default: `sobel`.\n",
        "        order (int): the order of the derivatives. Default: 1.\n",
        "        normalized (bool): whether the output is normalized. Default: True.\n",
        "\n",
        "    Return:\n",
        "        torch.Tensor: the derivatives of the input feature map. with shape :math:`(B, C, 2, H, W)`.\n",
        "\n",
        "    Examples:\n",
        "        >>> input = torch.rand(1, 3, 4, 4)\n",
        "        >>> output = spatial_gradient(input)  # 1x3x2x4x4\n",
        "        >>> output.shape\n",
        "        torch.Size([1, 3, 2, 4, 4])\n",
        "    \"\"\"\n",
        "    if not isinstance(input, torch.Tensor):\n",
        "        raise TypeError(\"Input type is not a torch.Tensor. Got {}\"\n",
        "                        .format(type(input)))\n",
        "\n",
        "    if not len(input.shape) == 4:\n",
        "        raise ValueError(\"Invalid input shape, we expect BxCxHxW. Got: {}\"\n",
        "                         .format(input.shape))\n",
        "    # allocate kernel\n",
        "    kernel: torch.Tensor = get_spatial_gradient_kernel2d(mode, order)\n",
        "    if normalized:\n",
        "        kernel = normalize_kernel2d(kernel)\n",
        "\n",
        "    # prepare kernel\n",
        "    b, c, h, w = input.shape\n",
        "    tmp_kernel: torch.Tensor = kernel.to(input).detach()\n",
        "    tmp_kernel = tmp_kernel.unsqueeze(1).unsqueeze(1)\n",
        "\n",
        "    # convolve input tensor with sobel kernel\n",
        "    kernel_flip: torch.Tensor = tmp_kernel.flip(-3)\n",
        "\n",
        "    # Pad with \"replicate for spatial dims, but with zeros for channel\n",
        "    spatial_pad = [\n",
        "        kernel.size(1) // 2,\n",
        "        kernel.size(1) // 2,\n",
        "        kernel.size(2) // 2,\n",
        "        kernel.size(2) // 2\n",
        "    ]\n",
        "    out_channels: int = 3 if order == 2 else 2\n",
        "    padded_inp: torch.Tensor = F.pad(\n",
        "        input.reshape(b * c, 1, h, w), spatial_pad, 'replicate')[:, :, None]\n",
        "\n",
        "    return F.conv3d(padded_inp, kernel_flip, padding=0).view(b, c, out_channels, h, w)\n",
        "\n",
        "\n",
        "\n",
        "def spatial_gradient3d(input: torch.Tensor,\n",
        "                       mode: str = 'diff',\n",
        "                       order: int = 1) -> torch.Tensor:\n",
        "    r\"\"\"Computes the first and second order volume derivative in x, y and d using a diff\n",
        "    operator.\n",
        "\n",
        "    Args:\n",
        "        input (torch.Tensor): input features tensor with shape :math:`(B, C, D, H, W)`.\n",
        "        mode (str): derivatives modality, can be: `sobel` or `diff`. Default: `diff`.\n",
        "        order (int): the order of the derivatives. Default: 1.\n",
        "\n",
        "    Return:\n",
        "        torch.Tensor: the spatial gradients of the input feature map.\n",
        "\n",
        "    Shape:\n",
        "        - Input: :math:`(B, C, D, H, W)`. D, H, W are spatial dimensions, gradient is calculated w.r.t to them.\n",
        "        - Output: :math:`(B, C, 3, D, H, W)` or :math:`(B, C, 6, D, H, W)`\n",
        "\n",
        "    Examples:\n",
        "        >>> input = torch.rand(1, 4, 2, 4, 4)\n",
        "        >>> output = spatial_gradient3d(input)\n",
        "        >>> output.shape\n",
        "        torch.Size([1, 4, 3, 2, 4, 4])\n",
        "    \"\"\"\n",
        "    if not isinstance(input, torch.Tensor):\n",
        "        raise TypeError(\"Input type is not a torch.Tensor. Got {}\"\n",
        "                        .format(type(input)))\n",
        "\n",
        "    if not len(input.shape) == 5:\n",
        "        raise ValueError(\"Invalid input shape, we expect BxCxDxHxW. Got: {}\"\n",
        "                         .format(input.shape))\n",
        "    # allocate kernel\n",
        "    kernel: torch.Tensor = get_spatial_gradient_kernel3d(mode, order)\n",
        "\n",
        "    # prepare kernel\n",
        "    b, c, d, h, w = input.shape\n",
        "    tmp_kernel: torch.Tensor = kernel.to(input).detach()\n",
        "    tmp_kernel = tmp_kernel.repeat(c, 1, 1, 1, 1)\n",
        "\n",
        "    # convolve input tensor with grad kernel\n",
        "    kernel_flip: torch.Tensor = tmp_kernel.flip(-3)\n",
        "\n",
        "    # Pad with \"replicate for spatial dims, but with zeros for channel\n",
        "    spatial_pad = [\n",
        "        kernel.size(2) // 2,\n",
        "        kernel.size(2) // 2,\n",
        "        kernel.size(3) // 2,\n",
        "        kernel.size(3) // 2,\n",
        "        kernel.size(4) // 2,\n",
        "        kernel.size(4) // 2\n",
        "    ]\n",
        "    out_ch: int = 6 if order == 2 else 3\n",
        "    return F.conv3d(F.pad(\n",
        "        input, spatial_pad, 'replicate'), kernel_flip, padding=0, groups=c).view(b, c, out_ch, d, h, w)\n",
        "\n",
        "\n",
        "\n",
        "def sobel(input: torch.Tensor, normalized: bool = True, eps: float = 1e-6) -> torch.Tensor:\n",
        "    r\"\"\"Computes the Sobel operator and returns the magnitude per channel.\n",
        "\n",
        "    Args:\n",
        "        input (torch.Tensor): the input image with shape :math:`(B,C,H,W)`.\n",
        "        normalized (bool): if True, L1 norm of the kernel is set to 1.\n",
        "        eps (float): regularization number to avoid NaN during backprop. Default: 1e-6.\n",
        "\n",
        "    Return:\n",
        "        torch.Tensor: the sobel edge gradient magnitudes map with shape :math:`(B,C,H,W)`.\n",
        "\n",
        "    Example:\n",
        "        >>> input = torch.rand(1, 3, 4, 4)\n",
        "        >>> output = sobel(input)  # 1x3x4x4\n",
        "        >>> output.shape\n",
        "        torch.Size([1, 3, 4, 4])\n",
        "    \"\"\"\n",
        "    if not isinstance(input, torch.Tensor):\n",
        "        raise TypeError(\"Input type is not a torch.Tensor. Got {}\"\n",
        "                        .format(type(input)))\n",
        "\n",
        "    if not len(input.shape) == 4:\n",
        "        raise ValueError(\"Invalid input shape, we expect BxCxHxW. Got: {}\"\n",
        "                         .format(input.shape))\n",
        "\n",
        "    # comput the x/y gradients\n",
        "    edges: torch.Tensor = spatial_gradient(input, normalized=normalized)\n",
        "\n",
        "    # unpack the edges\n",
        "    gx: torch.Tensor = edges[:, :, 0]\n",
        "    gy: torch.Tensor = edges[:, :, 1]\n",
        "\n",
        "    # compute gradient maginitude\n",
        "    magnitude: torch.Tensor = torch.sqrt(gx * gx + gy * gy + eps)\n",
        "\n",
        "    return magnitude\n",
        "\n",
        "\n",
        "\n",
        "class SpatialGradient(nn.Module):\n",
        "    r\"\"\"Computes the first order image derivative in both x and y using a Sobel\n",
        "    operator.\n",
        "\n",
        "    Args:\n",
        "        mode (str): derivatives modality, can be: `sobel` or `diff`. Default: `sobel`.\n",
        "        order (int): the order of the derivatives. Default: 1.\n",
        "        normalized (bool): whether the output is normalized. Default: True.\n",
        "\n",
        "    Return:\n",
        "        torch.Tensor: the sobel edges of the input feature map.\n",
        "\n",
        "    Shape:\n",
        "        - Input: :math:`(B, C, H, W)`\n",
        "        - Output: :math:`(B, C, 2, H, W)`\n",
        "\n",
        "    Examples:\n",
        "        >>> input = torch.rand(1, 3, 4, 4)\n",
        "        >>> output = SpatialGradient()(input)  # 1x3x2x4x4\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self,\n",
        "                 mode: str = 'sobel',\n",
        "                 order: int = 1,\n",
        "                 normalized: bool = True) -> None:\n",
        "        super(SpatialGradient, self).__init__()\n",
        "        self.normalized: bool = normalized\n",
        "        self.order: int = order\n",
        "        self.mode: str = mode\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return self.__class__.__name__ + '('\\\n",
        "            'order=' + str(self.order) + ', ' + \\\n",
        "            'normalized=' + str(self.normalized) + ', ' + \\\n",
        "            'mode=' + self.mode + ')'\n",
        "\n",
        "    def forward(self, input: torch.Tensor) -> torch.Tensor:\n",
        "        return spatial_gradient(input, self.mode, self.order, self.normalized)\n",
        "\n",
        "\n",
        "\n",
        "class SpatialGradient3d(nn.Module):\n",
        "    r\"\"\"Computes the first and second order volume derivative in x, y and d using a diff\n",
        "    operator.\n",
        "\n",
        "    Args:\n",
        "        mode (str): derivatives modality, can be: `sobel` or `diff`. Default: `sobel`.\n",
        "        order (int): the order of the derivatives. Default: 1.\n",
        "\n",
        "    Return:\n",
        "        torch.Tensor: the spatial gradients of the input feature map.\n",
        "\n",
        "    Shape:\n",
        "        - Input: :math:`(B, C, D, H, W)`. D, H, W are spatial dimensions, gradient is calculated w.r.t to them.\n",
        "        - Output: :math:`(B, C, 3, D, H, W)` or :math:`(B, C, 6, D, H, W)`\n",
        "\n",
        "    Examples:\n",
        "        >>> input = torch.rand(1, 4, 2, 4, 4)\n",
        "        >>> output = SpatialGradient3d()(input)\n",
        "        >>> output.shape\n",
        "        torch.Size([1, 4, 3, 2, 4, 4])\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self,\n",
        "                 mode: str = 'diff',\n",
        "                 order: int = 1) -> None:\n",
        "        super(SpatialGradient3d, self).__init__()\n",
        "        self.order: int = order\n",
        "        self.mode: str = mode\n",
        "        self.kernel = get_spatial_gradient_kernel3d(mode, order)\n",
        "        return\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return self.__class__.__name__ + '('\\\n",
        "            'order=' + str(self.order) + ', ' + \\\n",
        "            'mode=' + self.mode + ')'\n",
        "\n",
        "    def forward(self, input: torch.Tensor) -> torch.Tensor:  # type: ignore\n",
        "        return spatial_gradient3d(input, self.mode, self.order)\n",
        "\n",
        "\n",
        "\n",
        "class Sobel(nn.Module):\n",
        "    r\"\"\"Computes the Sobel operator and returns the magnitude per channel.\n",
        "\n",
        "    Args:\n",
        "        normalized (bool): if True, L1 norm of the kernel is set to 1.\n",
        "        eps (float): regularization number to avoid NaN during backprop. Default: 1e-6.\n",
        "\n",
        "    Return:\n",
        "        torch.Tensor: the sobel edge gradient magnitudes map.\n",
        "\n",
        "    Shape:\n",
        "        - Input: :math:`(B, C, H, W)`\n",
        "        - Output: :math:`(B, C, H, W)`\n",
        "\n",
        "    Examples:\n",
        "        >>> input = torch.rand(1, 3, 4, 4)\n",
        "        >>> output = Sobel()(input)  # 1x3x4x4\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self,\n",
        "                 normalized: bool = True, eps: float = 1e-6) -> None:\n",
        "        super(Sobel, self).__init__()\n",
        "        self.normalized: bool = normalized\n",
        "        self.eps: float = eps\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return self.__class__.__name__ + '('\\\n",
        "            'normalized=' + str(self.normalized) + ')'\n",
        "\n",
        "    def forward(self, input: torch.Tensor) -> torch.Tensor:\n",
        "        return sobel(input, self.normalized, self.eps)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:17.762957Z",
          "iopub.execute_input": "2021-06-02T07:31:17.763198Z",
          "iopub.status.idle": "2021-06-02T07:31:17.775043Z",
          "shell.execute_reply.started": "2021-06-02T07:31:17.763174Z",
          "shell.execute_reply": "2021-06-02T07:31:17.774268Z"
        },
        "trusted": true,
        "id": "6OfkWr79GYkH"
      },
      "source": [
        "class Toys(Dataset):\n",
        "    \n",
        "    def __init__(self,data,channels=3,transform=False):\n",
        "        self.data=data\n",
        "        self.transform=transform\n",
        "        self.channels=channels\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.data[('train', 'dat')])\n",
        "    \n",
        "    def __getitem__(self,idx):\n",
        "        if self.channels==1:\n",
        "            image = self.data[('train','dat')][idx][0]\n",
        "            \n",
        "        elif self.channels==2:\n",
        "            image=self.data[('train','dat')][idx]\n",
        "            band_3= np.zeros((96,96))\n",
        "            image = np.dstack((image[0],image[1], band_3))\n",
        "            image = image.astype('uint8')\n",
        "\n",
        "        elif self.channels==3:\n",
        "            image=self.data[('train','dat')][idx]\n",
        "            band_1 = image[0]\n",
        "            band_2 = image[1]\n",
        "            img=torch.tensor(image,dtype=torch.float64)\n",
        "            band_3  = Sobel()(img.unsqueeze(0))\n",
        "            band_3 = np.asarray(band_3[0][0])\n",
        "            image = np.dstack((band_1, band_2, band_3))\n",
        "            \n",
        "        image = image.astype('uint8')\n",
        "        if self.transform is not False:\n",
        "            dict=self.transform(image=image)\n",
        "            image=dict['image']\n",
        "            \n",
        "        label= self.data[('train','cat')][idx]\n",
        "        \n",
        "        image=torch.tensor(image)#,dtype=torch.float64)\n",
        "        label=torch.tensor(label,dtype=torch.float32)\n",
        "        info = torch.tensor(loaded_data['train','info'][idx][1:],dtype=torch.float32)\n",
        "        info[0]=info[0]#*5 + 30.\n",
        "        info[1] = info[1]#*10.\n",
        "        info[2]= info[2]#*1.\n",
        "        if self.channels>1:\n",
        "            image=image.permute(2,0,1)\n",
        "        if self.channels==2:\n",
        "            image=image[:2]\n",
        "            \n",
        "        image=image/255\n",
        "        return image,info,label.long()\n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:17.777756Z",
          "iopub.execute_input": "2021-06-02T07:31:17.778362Z",
          "iopub.status.idle": "2021-06-02T07:31:17.788646Z",
          "shell.execute_reply.started": "2021-06-02T07:31:17.778324Z",
          "shell.execute_reply": "2021-06-02T07:31:17.787789Z"
        },
        "trusted": true,
        "id": "Y26fxOK_GYkJ"
      },
      "source": [
        "dataset=Toys(loaded_data,3,transform)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:16.725964Z",
          "iopub.execute_input": "2021-06-02T08:00:16.726298Z",
          "iopub.status.idle": "2021-06-02T08:00:16.845896Z",
          "shell.execute_reply.started": "2021-06-02T08:00:16.726269Z",
          "shell.execute_reply": "2021-06-02T08:00:16.844889Z"
        },
        "trusted": true,
        "id": "5XbeOXYFGYkJ",
        "outputId": "1dd23bf8-3bae-461f-d44a-fe2e352f3239"
      },
      "source": [
        "image,info,label=dataset[0]\n",
        "plt.imshow(image[2])#.permute(1,2,0))\n",
        "print(label)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(0)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABojUlEQVR4nO39bYxsXXbfh/3W3vucqurue+/zMs8Mh5yRSJmEBUKILIOQJSgIBNFGFEUw/UEQZBsCY9OYL45NOw5sMvngBHAACzAs80PgYGDFIAIhtE0LpqAYdhxGQpAvE5GWHFmkKSmURM5w5pln5nm5t7ur6pyz98qHtfc+p6qr+3bf7tu37/T5A41+qzq165xaZ6291n/9l6gqM2bM+N6He9MLmDFjxv1gNvYZMx4JZmOfMeORYDb2GTMeCWZjnzHjkWA29hkzHgluZewi8sdF5DdE5O+JyM/c1aJmzJhx95BXrbOLiAf+DvBPAV8H/jrwz6rqr93d8mbMmHFXCLd47h8E/p6q/iaAiPwC8BPApcbeykKXHN/iJWfMmHEVNpzR6VYO/e82xv4DwG9Pfv868E/sP0hEvgJ8BWDJEf+E/PgtXnLGjBlX4Wv6y5f+77Un6FT1q6r6Y6r6Yw2L1/1yM2bMuAS3MfZvAF+e/P6l/LcZM2Y8QNzG2P868CMi8kMi0gJ/BvjLd7OsGTNm3DVeec+uqoOI/C+B/xrwwP9ZVf/2na1sxowZd4rbJOhQ1f8S+C/vaC0zZsx4jZgZdDNmPBLMxj5jxiPBbOwzZjwSzMY+Y8YjwWzsM2Y8EszGPmPGI8Fs7DNmPBLMxj5jxiPBbOwzZjwSzMY+Y8YjwWzsM2Y8EszGPmPGI8Fs7DNmPBLMxj5jxiPBbOwzZjwSzMY+Y8YjwWzsM2Y8EszGPmPGI8Fs7DNmPBLMxj5jxiPBbOwzZjwSzMY+Y8YjwWzsM2Y8EszGPmPGI8Fs7DNmPBLMxj5jxiPBbOwzZjwSzMY+Y8YjwWzsM2Y8EszGPmPGI8Fs7DNmPBLcaj77jAcGEZBL7t+aQPV+1zPjQWE29u8liEOaw5dU+wE03vOCZjwkzMb+NkNk91cnlzzQ/qcqs3d/xJiN/S2GhAauMPAdeI94DzGiw/B6FzbjQWI29rcVE68uk5919twzLsGcjX/LISLmtdsWvH/Ty5nxgPFSYxeRL4vIXxWRXxORvy0iP53//p6I/Dci8nfz93df/3JnHIRz1w/nZzxaXMezD8C/oao/Cvwh4F8WkR8Ffgb4ZVX9EeCX8+8z7hmqavvwfpiTbzOuxEuNXVW/qar/bf75BfDrwA8APwH8fH7YzwP/zGta44yXQHPSTeNcWptxOW6UoBORHwT+APA14Auq+s38r28BX7jkOV8BvgKw5OiVFzpjD6pojIjK9fbqSUETmt5y738ZcWgmDb0U1zZ2ETkB/nPgX1PV53sZYBWRg2daVb8KfBXgqbw3X427RIpoAoGXGrzGCOnt9/zi/eH3mhQd+tngr8C1jF1EGszQ/6Kq/qX85w9F5Iuq+k0R+SLw7de1yHvBHkHlbfrQaFIuuddOH3R3L7h/rm6Cm5xXETNucYh34BwSAjShRioAGhOkZJFLjG/VtbtPvNTYxVz4XwB+XVX//cm//jLwk8C/m7//0mtZ4X3AZcLJBG+Vl0gRvS+vfeBc3QQ3iTAkNLinJxACPDkG79EmgBeIisQIQ8RtOhgG0nOg679nopi7xnU8+x8B/izwt0Tkb+a//W8wI/9PReSngH8I/OnXssL7wly6uj5uc65uYIPiHdI00DSk5QJtPNo41DvckNDBm8ED0ue+gBjnROUleKmxq+r/m7wtPIAfv9vlzJhBDd9luUCfHKOLlu4Lx8SlQ6fMQVVcr4SzAbcd8NsOjQmJ6f4inbcIM112xsODOEvChQBtg64a+hPPsLQsvChotnnf21bLB8G3DeIdOkdpB/E4jd1d3HNqv9ccsr9fv6pXfIrZo1hm/LJQ+hqJQvEeCQFZLumfLhmOA+v3PcNS8J3ielBvXzIIsRXCxtF8s4UQkBAuXs/963Ld63mfeM2fnUdp7OL97r7zOp1gV/SK7xznDpPeby003e6D68TOddswPDGvvnlPiCtoXgh+o6RGSC1IhLiEsPYcr1pcCNYrML1WSS+G9de5nveJQ2u8Yzygd3sPuM3dXBPEaM+/6zDxpqWsh14lEHf5e7rG2sV7aFp00ZAa89yphbhQmlPBDaABUgDx5LBdicctcnKEhIDbLuyGE6OV5uBiaW4afbyO6/rA8HiMXeRm/d/7UDXvf9vjHFraZUSRQ3gb+tGdWBfeAWg/vNTrS9sgR0viUUt34ulOhP6JEleKfiz4LcQFpAbUWTgfl8LmgwVLnuLWA64boB+QbYcMEQ3Bztt6bd/TXhT2Gq7rQ8PjMfaCA3TRV6KQTp9TPiDFoz10z3tb3CXldhoBiDO1nRDQJpDaQGrMg9seXREFFycZOrG/qxdSEFLrkaSoqpWQhnxjCQEB9KHt06d4zZ+dx2PsmumUl/zvRsfpu13xiOKZXfYOmh6+931VpIjeJjFRzvXEk0oIIzvOO3j3GfHdY7p3W7bPHMMRpDaZsUfwW8V3ikTJxg6pUfojh98G1AneCa5ziAgSYzV8Wa/R6cegrAPerFd3k3Vk3DWx6/EYO9ztXXNyLE2KlCjcCaRX9/ByyV73QSnQ3MVaCgW2CG84MQJNCKRVS1oF4sKNnr2cluzZJeUSXF6KSg7pA2gQ1AkaHBIcSr4hJ7Xe/7114OTgeb/uOb+za7Z/sxF3pyKhj8vYHziu2rvL284Mc95C9KyFJ4sFcrSC4NFFC8EznCxIi0D/NLB96umPheHI9ucSQZIzr75R+74VJJlxSzSSDVjCThtHykYoQ0J1ASG/bteN6yo3mwO4zjl/ndesVI006Z2U5WZjf0gQMW93AJre7ppe+eBK2xoNdrlAj83Y06pBG0/3zoJh5eiPhe5EiCshLtWy7glQwfXg+oTvPTLkAstgNwN2vLxAgKSWB5Ah5e5At2Oc4v3l5xx2M/YH39hrvGZOAI9wNyXd731jL+W219nv/KplubK2TCKBnK3eDzXTZO3iLpKCHjKRJ3t0aRukCcjJCbpaEE9WdO8vSQtH98QTG2H7jhCXEFtIbU68BUChOXW4DhYvIuFFR7NwtEdCCuAG8+ztaSKcRgvxcxJRg4OolrgTwTfNmCPwLp9/Z+e39PyXUt3U0MvP+UZh3Xhy8Vq9Dkyv+S2u9SMw9kmDxOtKmk3LcpeEhAeXVhJU2dtpTND3V6/TCeJ2L5v2PEyDLxx375DV0phtz04Y3lmxfbfl7Pu8lczeg9Qq/bsRXeb3IUAvuLXHbYT2MwhnyuLjAf/ZmjY4UmsZ+GFjxr74tMef9WjIlFkvpEqfDYhPRqltQmXaFagqdDlzl/YSrEnr71Ju6FdEBHeOcs1vSbz53jd2yCfpHhNcrpB3roi9XqUEdNV7uAWJ5UYoLa5OqneTJoxRTVlHScAtWnAOPVqSGk/3/oruWaA7dvQnYrXyoKgHBoGtQ6IgUXCdEM4Ft4X2M6U5V1wX7XXUwneH4jtBktqX7r1l49uYAFs2UjLLrnpmEdvvi1jJThzivd0ASlSVIza5iTd37vJ24JQuT+CV63woSnT+laPU731jv89e7wnunIp5RWRiJasDEcVrUG9xywVyfIwED6slGjzpyRL1rnrU8btYRj0I/bEQG6F7JvQnmQHXqGXQ82e6eSFI8oRzIZxbia19nvCdsvpwi99GpI9o4xFV/CaiXnC9QgIZLnmfAsk7RBRdtkicyKM5h4aJQaoiQ4SYkImHL9sChuHaQiBWbThwYyiRwiX5gHLNpNyU6lonHv4Vruv3vrG/DUjJvMwVCZ1Xikzuom489dROchZ9iTYBzT3m8aglNW4seXlIQVAvDEsheaE/htQIwwriqmTNyaU0++63Fo6HcwvZw1ZpzlPOwA/IZhglUpPiotpWGyvDTT/8ojnBtn/aRHajoPL79G+Tcy3Fizs7vpa70/R63DR7liOgUrK7dYnumpiN/SEgxhoyPqh6ughutbL96aK1Pff779C9d0RqHf2JR73Qr8ywi4cuHWkpwHBkxh8XuV6eQ3bXQTgVXIRwBm6wcpoblLBWmrNkWffzAddH3IuNecK2sfp5TLiNeUZf7keDGZ3ElFPygpvaoRrTjibYY/ZvrtnDazKvTmbz7ZyS8vswVBlvhpunykvJTmO0aOEAive/EZ36CszG/gBQPzR3jdvmKcTVUFKWS2gC8bilfxqIrZXIkhfiInvpDAvhs7GvMnd9oTuPkST4zoy+fWEiFL4rxp6NfEi4dW8SVFkXv94ME7hLjEwUiCV6mHjpuhd2tjffe7qKgJsotYiMd5JDrzMMr06/Ld5ZjeV36U1edZe0dQvMxn4XmAgj3ggx7oTnhXRyU5jm2uUflukar0XQKFn0EJDjI1i0xPefEI9aNh+0rN93xMbKZDUBBrhc7y6efde47XtYWyNL80I5+igR1onFd7dIH2s+U1IyA9cx26aLkUoqQ0Kior3kxJuzyKLxqMvJumilNInT0N6ScAQ/evW8R9frZNZFTANPBNGtjU+p/8v786s+A5ogpp2wX0TQphlvMClNSoC5Qy9FtH/1z0fBbOx3gaKsckPsK6Eq/tXu4KovpVWWUPBaBI1S+29bWC7Q1YL+nSXd08D6Pcf6c1K9tSi4zGSDvLV12dAd1U0aKQb8xgx9+Yly9I0N/rxDvvVdK3uFYEmtEMwgS/KsGJnLoXqugwsYw6wBwUpxWjL12Npk3/uLbTnqXjzfUCT/rJcqsGU0wZ7fHeiz8P5S6qwdXuraK5wg7OUQGh1v4OW6poiq3Ers8+009uv0pd80A39Avebay5legMvC8QOEm+pp60OuCBmdoLx62UWTZkN/SflOHK5tkJNjZLk0j75qWH/Q0D0RuifWW26Ga0bevgDXKWENvrM9eWwEdZkcI1Sjb04t6dacRtxmMC8dggUHSY1roL0JSTqH9Nlj5t/rOnOSS51Dm3xjaK0KIDFmDzmh0OZwXPMgTBYYVVfG6CAet2gQ3FGbbypZwTZRhS01WKlOQ6b9Aqp7ZrRvkFNSlJ+UHw7BM958ku7kF6efj/rZucHn4a009uv0HWt3A6Nw/m5KZRPyxcHXcBc/FNf25OWxr0oO2u/fPoRMQJLjI3jnKel4yfqLR/THjtMfcHTPFPVK8pY5b1+A28LxtyNhnWg+y6SWhSctLKRO3gzT9SnfIAZkG60TbZvn0zUBCR4930BvvPWdvXBOlIlzFmm0TTY4h3pPWgTUO+LCk7zQdmk01n6w5ze+PgfniMtgUUEuEabGEo7J5+1IUlyn+G3CxYRbD1RpflUrPZaQfv88ur2SWyZLiVxM+O3Dcgk6Pv+yz3n+PNiMv+s5trfL2G+i6PIyUsvOQ6953JclvO5Dk+qQCsx1b2qXnb9sWG65sNLayTHxnWPiqqE7cQwrIba2D0fBdxaO+7Xit1YPd9uE6yKuG6wUJmKlOpeTXkPeQ/dWK5fi7UrZcf89TM9lciOZJXt1dWboBGdNL94RW5dzBXa8uucvhxIZ+QD5OeqwsqHPijg51+AKkU8d9CDBjTmA6VoPnVPV3XD9ppGYdya5nSOHu6rSvD3GfkMlESlTQ66D6xyzdDC96dJYUYGZvLdrESwuG+6Q+8nFe+TZU/RkRf/eMadfXjIshfXnjOU2HJlHb14I7XMIa2X1ccJ1SvtZj+sj/qxDzje4oRnD59J5ln+X3gY7kJKRV65zPksJzDur7zcebcyjp9YzHHtSI/RHjuSFcBbtg50S0g9o8Kg3zfl43BBbR2odsZWsdGMc+1JdsBKg4HslNYrr7T24IeHP+p28wUHcptNNxG5iPncJ9nJlee4meHuMHW5OJrhrMYI3behTTN/bNfqezcNO9nzFIzlnNw/v0GVLOl7QnwS6YyEubH+eWkCspOUGCBslbBS/SbgcMsuQqhHXL7gY4hZvO8m01yaU3QVPfpaR2urGdas3j5wa48jHxhKHJVTH6fi8YB49to7UmKHvGHslAtmpTFh5ULwlF9ULmmRc71W45eekkm1KbiKX5+zQr37st8vYZxzEDkHjuolJ55DFwjzmsxNYtGy+eMLmcw3bp8L6g1wrb+3D5c8F38PyO8rxhwNumwhnAxIT0mcSSh7HJM5Bf8k6hphJLxNDLzeJErp7bwnTomIjkrPgribpUnDElbd6/5FRcuPSQvDhyDE8WRjxZtWQWk/3rCW1Qn9sZcPUMjF2jFJbraEYueK7/Tdw/yjlOVKyHvlXNPjZ2L8XUJo0VK6fNhCB1to909GCdNTSPQts3hX6E2F4opY01tGj+zU0Z0rzWT8SXqYU1ZgNPvlLw9wLzLWUmYM7bbxSVWxqCW5i6PYYSNmrx0ayoo0Zb2yMk++i7dFT6xiOnIX6q/zY1vIQOFvu7hotKJjyBC7FfUR7pTwncisxjLfT2ONLSkivA9e1ojvoOwYufY+3Jd5MO9ZktURXC7afP6Z/GnjxuzznX1RSSGiryCA0zwW3FY6+pSw/jbTPB9u3phy6Tz/sg1UKpGSop8mrYqgxZmKJjjTh8gEOwaSpFm0lr+BKr3m5kSQ7/lFb99rDipxRNwPdviPEtkUySy554+SnYMo3qYG0MJ5APa/JohcXyf3wlqRz0ZJyMqhFMJsB6Xqrs09yDrdmQZYuwZehaWoUpTpez+vkk95KY38QibJDKO2eSU2U8VXXeEUJ75WJFZl4o2AlQO/R1YJ0vGD9QcP2HeHs+xX/u87Q6NDOk9Yetw00p3D84cDym6fj3vzQ8YfBOOOMCTkgs9aymGRM9pj8vd5EJW8rmoC2DbqciC8mcOebnYhAotaGm7gorbJWwtbcWVcyBirj/4ZjJTUQl2q982rttNLZTY1i7NHELSUab99FY+1Jb8ZOf6BrbY8ddyP4zP67quJUPLx3482lqtnw0pLs22HshUTzpjXYXlL6q0Z4oJ/92uW9gtK3fNlrHFyAO/y8ItEMyGqFOz6CoxXd507oTwLbd6z1VEMiDp54HvCfefxGWH6shHNwXRrr1KX/u5a2Rs55iTp0L4y3EpIbhzZo/io0U+/R4xW6ai3T3mZFmDQeXyZRQSpttJmlJwpStCeCJRXNaPM2ZFMWIbURJ61NXloGcL2w+ISsWps9+5B75CO43F5bDF27fjd6S5NI5bLLUxJuh5Dfp6JcJoB5Jcq1v8JEHr6xF8LLa+jNfqV1XBO3IukcUKO57fOm5bX4uWcMzxa8+F0L+mM4+xL0JwltE5wFwseBJ/8QwhqOvzXgNxG3tT5ygNKQUokrRGs8cTZiWbOHn+KC1yk3JCe1yab/4An9SagZdvOs1srqF9ap5rYD0kfSwmc9+ZIht/o/CdJTKxX6TvBrM+b2uYX0TaDu09XLaMy9cvSdiOuV4ciSeL7PDTrbiDvtkK5Hz9c2A34YoL9EmvwSaJHLPmTwmoxQJA7a5uL/X4ba6375TeLhGzvUxoAHGbo/IEzLaWW/W3TWZNHanPNnJ8SnLcOxt97ypaDesnDSC3SOsBbC2lpNXWetppANK6mFktNrkfaJJg50f7Di3rUr0Y+zJJwGT2osmVaIMeqMyZoEpHG2fR9cDuEz+22SRKyhdxJju5V992Ae2+VihTrLtqvX6v3dkPflQzKVHFeOl/8eozXMxJjzDjfPist1BShT7hC848/7wzf2MpRgNvSXI8s009gEVJxDT1ZoG+jfWdIfB/pjx/apIy6E7bug2Yn4jaN5IYQz84Kr70R8l4zempTUeFIQq6t3+3vVvXLaAVQjyZC2hUVA2gZdLdA2MBx7upPCf7dQOgVw0W5iKQoBq6PHpTNhjMYeR7LQ3A1G4fXBuuvCmRI2sPzY3k9cuiqsUbLwdqOgylq5HMr7TSScD0aVPd9Ys07Xo91rrMdpuhMCzSE8fGOHR2noN96zwbhndj6LPHjS8cLqzE8buieOfmWltTRRcCVnn/3Gesubc8UXj15OvWP0pNN1Fi53eskNedqLjm2fpZTTnBFeCqll5/hJUKe1my15h0tjma3s14vijYta1WZNdpocihudVwVIFj3I9NNfyv5C7Xt3g+L6VFl/mj37axcYeU2067fD2O8C8vIs9pW93ilac80rihXUktmB2eX7I6RFBJrr79vGmnSeTb5a0H/wlLTwbD7XMCyFzXuO7ol58tiW9k8TdWzOwG9h9Z3E8ju2DxU14+6f2jok5ucoMBiJRvqcMIsjBfbaKBTYJpCWgbRsKhOuSkGX0Lx0rwnEhau6dq4WZeyxzbntsdGE3whho7RnCbdVwrnRXCWp1d7LlsFZzR2BuHKgGN32bMBvBtyLTd2ra9ehXY8W9Zi3bAjk4zF2eGl9WuQlUr3X6Bu/9KnTXvX918jlk/F3d3Xmdh9Nu9MHrssFw5OGYeXYvOvoj4Tte9A/SeY5ve3Pm+fmAZsXSnOmLL/Ts/jonLQIDCfW7ln20H5jdWZUq7gEhSBTDL6+2WsYfc7Cq7cW1dQYr73o0pV3Xg29HDpIDcPNA4sNiUijBweH78F3piPv+2SddinhVHPt3hsxp7Gbt4pUBl3zAkvKrXtk28G2Q7db8+olSbx/zd4CfO8Y+0v60XdKX5epeh4i6hwaMvEKve/TqEJC2O1jv6AierH3/eIBR+lmaRsz8uMV8WTB8KTl7AsNcYk1skwIJGEt+HOH76D91Oigy09MMcZvE9oGK6+BiTp2Zrh+ayQa10XLwmdih0ySc2NJ7cB5LMIOJWnYNpUhp1nbveyd6yy3aeNYPh+F1WZlMSjxtyRonw+4LtG8wDrteltvXV9JXJKz/NtozS3byblWaD5ZI+dbZNOhm63toQvXv/SR3yDCk9JD71xtix1f75ZknBvg2sYuIh74FeAbqvonReSHgF8A3gd+FfizqvpmmMQ3KYuVMPqa+64q9lf6yMt24FVDuEKCmN4vmubVBg6UHu+2QduG4Z0Vmw8WdCeO8y+YNlz3XjJ+e7LwOJwJR9+0RpbldyN+m2hedEg3kBaBuPCmu5YTZH5r58oNhVRyoGutSjxdnlyqssplOEPTjN1oZf+tljE3g2fnGk338qKaRz5Z+O76hItKeNFZLXzdVc06wMY/P13t0G3dkExWSvN7Kt9jQl6coZstaVJeq/v0m2gQ1Bdzo7Z+CDv5mPuc9nsTz/7TwK8DT/Pvfw7486r6CyLyfwJ+CvgPX3kl5QRcZYSXJK1u1I9+med5WUKs9JEXWuNlgwJeYSRQ3XNf+wmSRSAX4BzpeIUuPP2Thv7YstQ421/7teB6Y4e53kLUsM7ijn0aRRh3pJSpYo4S7TG1pp69es2+5+8aczh/qMR2CM6YYFUaevI49TAEATJ5Z9I757KROwEfLTnocnlsur4py08kItsI/uK1N626lHvtzYNrpv3eto+89uAXfcJD56JImpXP5m3wEgr5tYxdRL4E/M+B/wPwvxK7Nf0x4J/LD/l54H/Hqxr7ZEb2pcSZG/azX0DKc9UP4TqRQRnTVEY8XXbhLiNN3BHEjXvz9PQIbTz9swXDyrN517N5z7rV1JlnXn4kuAEWn6WawHKdeWnfmwEbMcVX0UXrZMtCDSUZNzGi6jU7u1ba9xb57FNIryKR5L5t9b72vBcMS6PAqrfOtGrrarJWYWM8AL/Nhr+xcNx1g61v2Ov/Lnt1kcsTiSnZ+1C10P0uQmufP1dlCg0XqyxSxlMlvdEAigsokecVN6frevb/APg3gSf59/eBT1Urc+LrwA8ceqKIfAX4CsCSo0MPMZQ3fBXuMft5aemr7Kf392xl/+wPKMncFtNIIe/7tAloa+INceGIueZcwt1C+QwbNY9+rjTPTVqpZLoLm9d02Zg60EqUqYoymRZ70KNPhTT2ymv1WOXa1QjJog/2TqNK1q4L5Kkx+UClNOZllIfWnJgbkmm3lz76/Zp/+RvYLL3LhCeGob7vV/HoFz4zztX3+0ql1DvGS41dRP4k8G1V/VUR+aM3fQFV/SrwVYCn8t5bUTAvpa+DF8gJNLueXWqodtdGLrVBoqJtrHbeOPonDRqE7TNv3rAd97t+o+bRn1virf24I3y2RttAXFmElJosnthQy1zXEmaYevSrws/p+KTs4UvV4JB0c+liS40lFZO37jQ7lr23cgdxUQmbaF79+dqShf1wsTIA1j67Xtva++HyNtHy3l9h1PLBz0weIHkV7GYZXz2Mv4GC0nU8+x8B/mkR+RPAEtuz/xzwjoiE7N2/BHzj5iu9R9zwRF5a+sp7r52LWvqu7xpZM23q2bXxxIVJLBVppZh7s9VZ7dn1loCzHnQzdn/eIeutJcEaTwoOhN0bCVw+L21PYaZ69CvOa+nMqueqePWroh+xLUjRgiteXHQ3nJeUs+19MfJYb0IHkSsFOozGfpW3vbEndnstqtf16Hrx5nQT6D5V+Qq81NhV9WeBnwXInv1/rar/vIj8Z8CfwjLyPwn80iuu9/Y4QFS5gGsY+06JpBhBYaTtP678Lw8d0Gsae2WbTeHcrtFNJJiqTHKRVVoGumfBerNXpplW6sPtqdKeJjP2cyuLSZ8QhbRq0PZpbvfMHWN7H0R1AnmeOWBh+zCG7WXg4XVxoeTk/LWSlxKN5KMeJDd2+M7+Hs6UZq2Ec9ODc5sOfXE27neT2mtODe+AMRwaqSQv8cJXIm/jagJ3KpA5RfbCtUx5g/N5CLWf/RrDP25TZ/+3gF8QkX8H+BvAX7jFsW4HTbcXiwDqiN09w7u0LJYlgzVc/OBculRJFxoidF+Qohj5VPo4yzMPK+OP29DEse4MENaJ5UcdMiR8VpEpU1LSIpCOXb0BHPSsYqG07ZH3/l9KbDfZy5bzmW+Y181nSDKRR815hzJcwkJ3JWwSYT3gzrfItiOdn++UsKRtTRX2yheRi564vWTrdlM0zeHprdOaeop3kwSs/ewvlwq/kbGr6l8D/lr++TeBP/hKC7wM7gYjiqYo3VOviDLqaIf0UMJ1d0mZbRLmS1KUOCaervrAlAED02Rk8USSva0XI7d4ITVWh46ty2osUlll7SmMU1CV9nm0sDbqeBwnkyx7qRXL2Avuxu6xospCTuKVKMQEJeNYzsoEGWtQkuvtNzWZ8UoOocvp6D3BOVLnaBvBDaVP3dRsU5PJNEKm8MKwdLijgH+yRJqA28++T8q4Wvrti+efkHvssRNy0mXX+iaYbv8OSEprVdy54/TVW9nPXsXvub7Bv2r/d4aEcJH00EzKfC+726dkHmh/1vfBF5Mctk9+DzYNlTzdRL0QVwF1Yl1ajYXrpXfb5Q6t5tSaVQoTTIbMV5c892wSsqO5Fu1lRy+9eHP1wDbXrrW0ek5UY4tBldFMySHFmA6NQppCU510qphcFMNgVFTvcUPENQEZEs0i5B7zZKKSS48GR3+cRSVboW9BosN3C9wyELyMWw8YRS7SeJPSFE2FZn9m+nQARVHTuSsUNZ5yGmpy8zU0urzN/eziBFW5Wdh409eoe+NcIvFuvLtfFXLedk2177x4LRk7vxrjixfjLnvryhHXTBWNSlgPlqTaDuPeOgE+R+HZa18gLO2/LS2lumn/9mjoO/ruxVO+6jlQ467XY5WvIdp7cbESXRyggyM5rZn6uLTau6jDxYDf5kTYZE2ut5uL9BH6AXGDTVx1fsx8T67Fldf8OtWJ6fGu6yBuikvKmzfBgzX20put/XA3+/E9lORR6f/ev7truCSZpHr94QYvQ5k+6o2iGpeB4TjUkURjC2cmw2RCTDjrYUi48+1uyanot7kwJuEah4rgYjoc4mW6qcTcBpontri1CSrKOnPDy/stc9TuCnmQA87Z+9mONwLbyuT8xMLEIjfvCcOx4jfCZu3xW0/7PGRFG8aGmC6Z3PX5YJNqmmCvs+129/eZbmzR0B5vvUQGV65fL1KEQ+CqUc83hebxUbfFwzD2K5oKxN1AHvnQ868U8Bvr4yO1cUL6OPTcu4o0XA7LJ3trpt7cm8cv3tz6s3MjyrrPs9K6MVRUvVj+qyWvfKxJ6ar2gcNEa+2SgQ/773n/dydX7hVtDZM98iHVWbh4E1GTs1ahikum1sQii55cCpiGXBy737wH9Q4vgovGnJNNZrDFuJsgLRWV6+RbDp0DvWGU48S0+OpxrvHhzuu9bR/9mzX2CU32UniPvOrAexgN+sJLSy0HSfC7Hv0mF/3G68khu4wePbV+woRzO1NP/drC6uZ0wJ9ukU2PnFr2Wcv+r7S45v3/oZKPhfPkhJ55eR1sf+621slWZZIHC393mlwugYigIZfVLisjFVmsySjm3XUdDn1taKMnLj1xgTX2PEvo+x1x45GNx3VCXI1iFRLBdYLv1MQ4VtbXvgDz8G5X16C+fv48qJQpsC8xrMLSu0GUU8/V9NhXZOW16vBf5OjbQMcDr30HdNnXg8uaA/ZxG5rslaUzPzahXFUbLbgjr77v0UuoWnq1d14vh6Wui2bo285ED+PYrCHTbP4kkQeMtfTi3aPWZFadYd6PyqnS9XXq6HUhmeIqIlw4Q2XsVOm1v0GZEpe9eUlQBtCF0iwHBqckIAXHoM7C9202+szCswGNDnVKOMtqtY0/bMiFd+DISa5r7NVfoXQm+bqPh7niZpHSFWy/G5ZBeVPG7vLQuuyxK/liCt0lyhx8zDVQ7+JFsrj+w5lHz3t2bZuRGAEXvdQknL1A9ZyWcm4A25vnMUYLV6eISsqSxsn20X6bQ+rg0ehrs42QQ7u8Zm0C8XhRjzktlbs+d4hNe7xL5r00kJxv0PV6tyae97PjokdePHvXR0sJs/ytCbBYWP/+k6PaK3+IKguMY6TKS3kTl/Rdojm3BIY7d/SbgK4D7tzZAMYNoEJqFFpL4olizTROCGtoX5TXXCLLOCYgd67HXonyVZEunp99XNX7r1UU5G5zVW/E2C9MNSn9vhNov5f0OER4uQnya+7s4aeTQRe7ry/7WdaSmDuUyCmls4Qlga4DKR7dSmvDymV5Y/ugul5xQ5Yx7iIkiwjE2U1Kk9W3pWivk419FWwk0tLKaq7PGXq0luakG8bZ5Tp+1/WadHpmXX1HK0uQlq6tghitVn6Ag46T3esYgh2rCaSTpdF8g9uJPMbzi8lA9RNjD+axZTCl20KuiRuP25gKrgwmLKliYX5a2Ax5iwqcjcTKJUwUNAgSPW4b7SZ6ANofmLl+E1zHSC8L34v+/GsQtLh/Y3f+YkIupYudSPt3vLJviXo9oYf9KMBNvE7xwhPe+YW7+V7n1A4JpswUL19qaqTX28Pt1njVj7RVNyiS952+S1YXL2vIdFlEbCpJSuP7yKovujRD1yzbhGYyClqFISXlc1iUZmIa9+fO41ZLZLlET46s/XTZmN55UWoZPOqzeEXwu11m5RoW2uiirR69e9ZazTzLRE9h67Kf1cUsIGkRi4tWqgtFbqpzEAUNSn9iz429kYK0UdSpUWwHsrpsnk93asatIjvJyWth/8Z/2cNuQn0twzL2UUL3t97YRQ72jasqsrdHvJCQmD5GLuknr6/jxlB08trk5NsFzyyyO9KoePFDhjv18CWZVy7aNWaOa/DWv+lyGF8ILYDvjfMtg+LXNiG1IC4siee3ee9ZMuaqdYrK8KS1BF+WSRYFyinLPHfz7tY4Iutt7kO37jVZtHD0FD1aMrxzxNgZZ951mrEnZi31qPU4AhDdKDe1XNC/f0xcec4/HxhWh9RpqVn0RRD8xlUxCheNMCT5TuAWav/fOtJRpHl/1CdQFdJ5gMHhzgS/EZoXwuo7ifYs0X60xnUD8bi1aTM3YbBVBt4V11X1Rv3oF3r/J8fRrru7qs8ED6P0xvXKCqr6cu7yoaTfdL9/KPM7LaMU7E0VPbCYi578umUYx5gMgqqmWqaPyKAmxJDIElGW1DGqrMM13rxtLs3VmvqE+lrfuk69udb3tdOQU5JGixZdLkjLNjP4LJRWyZFG1BzMCE7sOErKGfZJ+bIJ6KIhHbX0J4G4dPTH1rhTBjqM54yqJxe3YmH3IDin0LPThVf13QeBJKTJG9UkMDhkEKQo83R5OESnOcOeanRzUOc+X2fJ17USdSbX9dLP6WU3j8v+/oo987fBgzH2O8FEKWanMy3sGfo+iree/E6WKLqKIFE8/M7zXrrGrNCSyS6Q99WaJYw/WZvnzHt/PV7mspynP/Gjpy0NLblmjpgXTiHv+aNtTfwmZRWXnHEvnn06JHG5BBHie0/p310yHHm6p0apLbX+sHb4rSX4fJfQwZm2qhrFl8LwA+JxS5/Vbc8/bzJZm88pcZVM030SxJkBWxY9NYJfC74jj15yNGeuhvTqrbwWzgXwRGnHAyUIz70JdZwK4dyGXTSnibCxnAfJkpG+JOam10tkIrQ56QXYp7sWgYtD2PPqd0WGuSu8cWPf99QvHYx3FXKZR/ZD9Jc9b+qRy/epQsvLnlu+X6c2X7zoVPwiWe+56xOyzSF22SoUj+JGTfXUOPP+aXz96i1LDiGVKaRaQ/CdTPpUey6XH9Mq5LFQNkyiZKkkmbSV6cab58VTk5KQf8/lq2Hl6U8c/crRn5jw5XCspFVCtw43jbyUuta4MI+N2FAIL+SBD7nakCsVNs4JdOMmx4Cwyd58A36rdsMoEU1u+rH1viTUPuDRd6/5Nffmr6Jh9xpHkb9RYz/YU9z3B0/QzuCE/TC99Jw7sfneOwytMWzXKTvuEDJHu/68u4Cxe2yfQllKJcVwDh2/7PGDr+UnKaWvjYWV/sUWeX6ay47Jcg7HK8C8Xn9sjDE3OMRngx5yDT4m3MLb/5LiihfeDGMdfcgZ9FIxyFFQenKMLgPr71ty9oUsiLHKpy8nDDWXylWc3UQkwTIgqiRv0cZw5IkLYfPMsX3fZqJvP4hok2iedizbgfXZguF872OXyJNfHH5jApm+s3A9bKSOdyqTX5oX0H4mlohLFgWQIGyT3ZTKtmiwm0ZsHDxdWj/B8w2sJ97WuQuVmFfCIdXim9CK6/NvXj+/Lt48g26aREtqtc5DmciXDE6odeErjO1Kwkx+/Ut7tsvziwefPqbUVK8cp2w3GXVu3FerQsQaWboBWW9N7FALPTLU0NjIJWYUqRGKDFvRlJMh2QzxpHkEccrDCtPE0LMqbIxjwtJ7dNUQl4HtE8f2HSOvlKkxPhub6ySXBDHOfnAkEpCTeA66E8ewErp3hM17Slwp7r0tbTtwstrS+khKjk28eA00CXEYQ/UyxTW1uQmoRBaDSW75bZ4AE9UGWGTjlqh1iATYWjUPgnBR4Tk75VG9zbTdfdx2NNRr6AGZ4l6NXUR2SRcXymMHauH1f+6iwH490CvQaSdhWi2r7df/YVeFpiRtDmXcS3vkvmbcdP3B6LFF8NH1EaJWEQZisoy493VWW3yyIC5DDWFraJ7XXNpY7UYiVU/d98lIKsXQ+2FsBNl2tt7jFSxatu8t6E88688Lmy/kPEDeS6vk2WlHjJ1nE0+oDoaV3Yy6ZzCcKMNJxL3b0TYDT462BG8f4qhCHBx0FgngLLx2TcRabZUhCXQO6S18l76Mg2KSnyjnQZDoLPpIZLVZcF3eFg2W/HODDcdwvRKWAddPKNpTZ1PKr3Hcr1fF1tyzXwkv089RLQvfUl7qNeNBlN52HrLfb1z/Mek1v6vl7F+44u0mqPTOOGn13C/DTDjftRy3Dz+pk0cjw7h1b0Z4tkbPzoxttlzYUIMnR2jjGI4bm23mpU5LKdnr0es7CDmZVlhyhe+ehzpI11dD1/UaWa2M7LJq2L4b2LwjrD+vhC+eM/TeyljR6uU6gDHUIK6EPmaP6SF56J8oaWGc9aOTLe+vNnzh6NQy9sCgno/XR2yHQBwcMhiF1YxX8SHhfGJxMtCGyKYPdF1Ak5CSs36cwT4Tvk34EHFO8T7ly+FJ0dn2YHCEzzzNqdRknuuUhbMEY1o2dk72oTljD1WKus6ZT1YOO+i1C235LcD9Gnu5Q96EBTdRErn1a+8nXK4RcknSLCU1SW7Vf+5tDa5K6oA9NqXcyWYZ/1rP9x5xxuYzqeg8Ay1IHY1kAxLIe9z9dUCZ4mIRgJXbRh31CYmjyGk1ntR4hoWYFPUq8uxow6ZrWEdB+9xjryCL3FOej2/iF2ra7ifJ9uVNxLuEqvCiXxCTYxs9Q/R88vyIuPW4TxvaF5LLevlm0TnwSr8a8CERo0MHZ+W0XkAll9sgBiW6BrxCSDm0wb56t5PM04hJUSMMWaU2Lj3SN3l+e8rnsiQtxxtoxWX6hiWyugePfFe4d2PXrrvZuKOiJHIHxn5tKusUKfO1p62kBWUAwsTYL3sNDd6S26XMV8p7JakTQq1za2OZ8RRMikoDmSef68ZlAkqpIJUWWfJefSLeINvOZor3fVVYlbZBFgvSoiGuAv2J0D8B927Hj7z3HT7ZHPE77inbbaAfHOJllHSGnK1TtEkQlOaoo2kiwSfaEFl3Dc/Plwy9pz9tkc6x+NCzOs8joc8scWayU2QBTeifBlKZMIsl6Fxv7atuO7mRJXteakqEYa2wqQFc/r9XNA+akAFAiEvwXSA1LtOQsxrPOrMDi8JNuSnGVGexXyB5xfja99h3jXs19le6B8oBOd7LDP+2+mFT7N/hpx57v7R3jedLMipnbXDIHOiS8JOiwurFqLETKq2KjCWqtFdK23lNatQg5SY1fVwWJ7Sfc6edo375EHkStmxCQxsGYnT0TjNfX+qeWSVZJBEU8SnnK4WYHJte6HtP3wVS53FnHre1sdDNqRLObXBFGQQRkzWySAtpu3sujTYs+TtjG2vS2tuuuTNOPVayC3YecKBopQ2nkJObubNQBrEejSLjlBirKoXwUhOlb4/3vgpvvM7+SrhsIMNdhPswluAOlU5EXj7i6dDzg2bttThm3Esysm2sGWe5IB61WWjS9ulFqUaG8uG3clo17Pxy6nLiL2lVm5kmEmWx2Dk3umyzmKWrSa/FoueHj77NynecDS0vfGJz3qKdQ3OIrCV8Fsy4ktCdZXJLZrbJ1uHXQtPB4hPzyqvvJprzVOetqzfhSIlmiNpZhCLDhH8Qx6Rbc27noMlz6lLIkUEwBRtLEFpNX4Pm0dQW9ovPyUYH/ZFg7j8n9VK+2WqyKGiIphMwDGi8QZ283LDFXT7C7A3jfrPxd3IQGUtsrxNXySZfdlOphJycoZ2y1FIyL5LSyMoqN60isBFKX7sbxSbK86cEmSHtUE5V1B6abNoqZbLLNBIp1YCC4DNttxwEgks88+e8CEtWoWc7BFxIlkGHXS6KYgm8JBCt5i2d1NA7rI3gEs5sLHTYJhv/XNpx3RhVlMEQU9GO8Y2Pr2dlRioJKd8Jrd5ezodoHTJR6vJ1tFV+vTKAYue6ZcKRaQTkevdN5beuq8/whnDv2fidETkHBjBcwFTArxpH/tv+cIXpSx3iPr8MU4bZobVPI4pDjy0GnhT6bocNpW2DsNjtAc+ad7pakI5GT2sltGRhZpmPnktprou4891GCck3ippwKolQEfRoaa+/atF2UjLL7DfXJ8KZWl1blN/Tfpul6zmNC74VnvLtz06I4mk/9jTPJctDFdqqJQ3DuWaGnVlX0YtTB/0ToRM4/75g++o8Kz41SjxOEBLNky1NE3nneM1R09NHzzZ6tn3gfNOSouP5JlcHBpd7BhI0to3wjWXzmybSiLLdBnTwxPOAf+GNAdhB2NggjeYs0bwYCC+2uM2AnJ6bRy+iIOUaXZZ9PyR1rmoeXdyD9OrwJkpve51oN5pLvkeYuTBcof6j1EVveNKn++h97KuPVm8wXnQtSbwYL5RqHJhh14y4VIUcbQNxGaoGHWSvlDu/iLlBZttb0m2z1xXVBOgPlStzh58X4smCuJycK2Wca75V4lpwAt8XXgDw8eKEpEIIiU4gnAqrj7SW28IaVt+N+C7RfrJFuqEOtNh8bsnZ9wXiErbHeU78uxFdJvxJz2rVcbLc8oWjU06aLf/I8Uec+A1fbj7miV/zIq74NB7xWTzim90zuhT4uDtimGi3HYWOp2FLcJGFuXm2KTAkz2+evs9HZyd86o5I5/aefWcU2rBJhPNIOOtxp8Zv0OenB6/ZIVw5V03VSgAPFPds7OwOursOGaaEoFXyWWp4VYczHMKUs37dPuOrymYpmWeZPnyYZNMvI12Ux8YI286MvEweycQZbXxttnFd7kpTGLvT1Iw8Hr6JSd5bTpN2hRosqihidNpOLhxbk5FSfK90g6dXx9L1/J7Ft2kk8jePv8QwOGBhzDaA7N37E8cQhbhYWV/5whEbYftM2LxvCbTuWUIbhac9TRuroR81Pa0fcJL4bFixSQ3b1NBI5OPhmE/7FWfDgo/WJ3TJ83yzYIiepCYx7lzCiyJS8hbCpmuIUawCsPaEU8fRx6ZUs/ooEbaJxXc6Gxt1vkXON9aosi8WccnQi5vMVXuIuH/PftN5WmWvWWrQgPT5pJfhDFdhT6j/lVHINFMUL77Xm3zIO5Qbg7QtcnSU+73bXOt2pOBwXdaAn85Yy9hRfN1HOQ+lS8tnEU3nTG4LTB562o9e1tX43AYqDNGx0cBT2fLl9pT3/Clfe/JDRBU+cU/wndZtU2pg+yxXC3JWP64gtsai698ZICTC0WBZ/qMtizBw0m45Ch3BJZbeOOqf9UbE/+34LoM6Ptke8WK7YN01rNctMTrSmYXxMoyceIkju06iEWjCAMfn2YuvlcVnVmJbfLxFtj3uxRo2W3SI9Zrse/S3sax2Hbwd2fhp6DzFtHvrMtzyTnxl/3IaPe3Lwj/ZScQZBVdLpKI5+RZT1WErBqmH3vt+cnASxWhhgjlne4EhjvX9PHyhqPJYT31RsIG+93w3noA/5T3paYmsfE/rY92r29x0qfLOyFjvjkvbj8eFglckKOJS1vcQhuTYDA2qlh84FSvex+RICOu+YUiOs23LZt0SB4eeByQK/txZ2+5AbYl1A7YdGYqx2yz6sLGtid+YKq/rIu5sa9NYNtuRc/Ca5J8eKt4OYwcOElYO6aAdeN6tUIgWF46bLlUbOYgykKJt0JWJQpYJrRKTzVNf98jZZgzHJ+o6FWUfPkFl4aVkBJosRknKRJ5uj6tQjp2PU/Tu+rOWv3H+g/zw8kO+3/9DnCSehjVP2i3fOFL6Y2PaGRce4irv4dv8fWEkG7zimlgl4lVhvW3ZdMqLSdgdo7Hkhi5r6q090lvZLmyEZhjr635DFp/MfPdeK8HIbywS8hsbg+XW/Sii2dmwCz07s1JaHaw4iW7e4tD8JrhnBp2d2Ltgw9XvV1yo6UW86WvqzmscCp1v4NGhenVxjjTNP1CScZMBisUYrYB+OYnHSe4UNIUXW28C/K6HP6TcM+3c07IG4ZPhiE/jEefq2ahtARx5yGJr/PgUQMt3b7RZPEZh9XYwzQMfYyw951JPJ4BGQaPpyUnnsmd2SG+ddmFT6uxa6+1uauydVp0+v7HxV3UM1rYzx7ATqvfX8+LXGVL5luKePbvte/U29NeScHvJhdM9aqveIF9QO5im24SkFxseinco4aDsquTujJjyWQK6bXbEIwFrbx3MK4+95pcTh9T7LMZgajfSF8mlBOs1RTNNyWVqkTo9VBYLK8cVzx5c5t0r/oXnb33y/XzWr2gksk0Nn/ZHDOqITyKbz4VaNiuNMPZkrJ49jDV3BtueaO5DL91rbsBq8cPYK2/EGSVs8jq2ybz2UObOKWFtrEOJxjGwluDO3ve2Hysj+QasOSIr2voXch1XhfDfo57+3j173efeZhbWSzx6fcz0Ynp/s6hiv6yWE4IHk281S3vAIxTP6p2VGTNN9YKc1RDHLrzi9Q8JbZSmlzzxFey0kvKAwlLhKI0amgk3MSfvCpOuDKYo10FNFebT9ZJVOOEbq3fpk2cdG9N6axLDKht6e/jcS6aeFg04gSom6baCi+A6M3Iz6rzX3maD3phx+22W0codfKRUZ8/V1yr772LQh7LnE2775dfs8eDNlN72iTJXPucAieU6zCa3v9d1LzX0qUfXrr/Qt/zSvZ24MXrY8xqyWqFPj22UcuPHxBvg1Pr005MlafGONYk0u2VJ15l+vJZW2awPV/ToSOCDwwWfk3GlS8bWLNpadLJakJ4swTnTcW8c3RPHsLIQ+tNPjzlbL/j22QmqwtmmZeg9cubNCydBu5ITyOF/8d6ZyWaz16Z77amajObmFtt3lxl2tQd/UAvHN1kuO29rirZ9+Qxo11fiUvXQ++IRl3WswfdsqH4V3iypZioG+TJcRXg59FLeAe6lj7v4GnmL8AqZWpnMEdt/ri5bhndWF6SUARIeJ0L/tGXzXqhS0AhVZimce8I65v/tUmnrawQhZDUd6eP4fcrkW7WkZUNqbPZ5CkJ/5BiOrLtMP2vZuoaPPlmCZv23BH6dBzbkTHgV0lB2fy/fo7HqmjObrlqGR7pt3mtnwcw6fip/t7B8GIdW7kuM17r4Ra/9uiSYv1fwZrLx15GIumPodcp0eUqHTqOHkrC5gvcsTlAmenoTZp8sWqRpSKuW4TiPFs4U2NSYgmtq81SYLLlcOsKAqsICLnfOSS15FXmrwvNOjRDbvAfPyrMWBue9blLSIlQjT03uANNMfz3FZLNKWW2C0n0mw3gDqlJRCcauPGp3mhuUZp2qTJZk4Y2yJle4BEWLrxh7GUFdhodMddn6wa5PNvq9i3z19X3keDPGvt8Hfh+oQv9XhG9ZkQTGbHwlWDiPuEtOl/fWWTUZTyVNsLB+tUJXC4anS7qnHtcri09tDXHpiAvH+j1H/2TkndcGEcbSk/3ua6ZeHQwLqYkyddnIoq/iFZJyOJ00y0BrHX1sarVQlHP8Vlh+V1l8Nr4tdeR5afk1xPjlpvmW69zAfu+yL2WxXmleDLksNoxknmLge9NSq8R1UYqpGgLpwrZKi5LMjGvj/o1dZPf7a8KF/fUN9mjXigKuwlRdZ6I8U6Sgy37dPGuWenpC3ftOPWseHlN3JIXBVjz6eIMQxI2ZcYnmsbW3rrB9DTeg0mbdIKizcFtLZJwjBzRn3nNLqdW3qfLP5bG2KPtWSmNV8DJmRuCEuVcFQabJ1ol8d+0nn0Raj6Ue/rpwLWMXkXeA/wj4fdgl/ReB3wD+E+AHgX8A/GlV/eQlB7LS033gEBnmJgZ/G8qkExu8EDzpyYp41DIcmfzTWA+zfu7+SDj/gtJ9scedBtqPzao12Ac7MfH42VBT0WjPUUBqywgpsU6BbBNTEUZ11hhXNNZFFbexx/n8hBJiFxHL0nOuXoit9ZCHjRLWuzTlFHKisEQTveI3poHn1739vdtT+Rmmmn6lzJlZg4X2OxlLPeP2uG4G6+eA/0pVfy/w+4FfB34G+GVV/RHgl/PvL8El5SQY7/CXfZXHXANan5d2v26CV83WVqXarDSb21YtdKZOWSlhdGqs7dMfDWijk55tYT+btzM2aZ8xK5OvaY/4tGdcyh67iGHkPXT56qznvHrk6f+GzLTr8zilSQ18HKmEPadPFz165UeksZmnfJVBhqrGB8jXa+rRZ69+e7zUs4vIM+B/AvwvAFS1AzoR+Qngj+aH/Tzw14B/6+qDsUP1rHXlcne/CuUuf12D7w4kcC6D9zdrtb0MyWq+4gRdNLBoiccN/XEgtjn89jZMQQNs33H0JzA8Mcnl04+WHP2OGXxsJ95brKW0eE4QtITRYrXrnYSa2l4dtf2zKb0kq19n5dkdpRufk3KNzXVPXkiL0uRih6ySzJs8Tqm8lOS7iivZeM03kcIIzNe4twYfvUzXH8br24/78Zo76a8/NHHGYVwnjP8h4CPgPxaR3w/8KvDTwBdU9Zv5Md8CvnDoySLyFeArAMvwdEcnztoyGctqV0BrjfWaF/wGpTO5I+WbUqeXFKpXj40l4erQAhFLennjmMcVsEgsQuQswuK5hchxYXvkuDBDLvLRmgUVjSiTvXXSHeWVsQymY4JuHXe44zvrbnydnFKy9LHdq/OXKa5DnjFXXssLKYm10WZDr624ufGmDqdQtVzGIWLSxMvrZS2ns3e/Fa5j7AH4x4F/RVW/JiI/x17IrqoqIgevhKp+FfgqwLPl9+mOUstN5llPj7nfM+7cRc+8P2ziqiSPqnmOCcT7HZlgaYIRZg69Vn2QCVxI01gtu/W1vCZRac9sv90fO2sFPYbhyF7jfNsQzoXFZwMyWG+4TVnxpMYy35aQE2LDwTq76019tkyE3XmLwTEcZ83644ZSKpuiEHmK1l35GaiDLQq7DSemVz99+7EYe1ZtzZn1GsHFLKNdePmFIDNkGah+MEMv+/Xp+mZDvzWuY+xfB76uql/Lv/8iZuwfisgXVfWbIvJF4NsvPZJycU7aq2Dvzi9Z8WWK/WETl4lK2P8OrCmX06avUcppVXziwHMI3oY8LOxL8yiiMo55OHJs3nXEpQ07jMdWD99uWhbnQvvxBhlS1ox3kMrMdcaJLO2EVKOT8lqntM+H6oGBOvU1Ll0VsTTF1VFKymV22zjIUZEuH7vf1btzXcRtTZVGvNutuinjDPhpY08pp8UIe9Wy6VxzHYbMaX97Bi+8TXipsavqt0Tkt0XkH1XV3wB+HPi1/PWTwL+bv//SjV+9lLiKx72q3LVXhrk2kt74ObX33H4xbx4CslyMo5mKmus00eTN0Kuxt9mrZ0/rN8ky5wFSCymoqbUqxM4YamVscAojd109xKbIIFtoP/Xs2lupzQcdZa2yGYpqlaOeijxKnpZq/QpGX52esyLW6GKyG0E5HVdcozILXqYh/B4uXOfpda1/mr3468B16+z/CvAXRaQFfhP4F7DL/5+KyE8B/xD40zd+9UyaUFXr+LrysWMZ5iaZ2eIpgBs9rybtgu2/ZblAT44ss75qUBFjgBUxiOKNlwENzgYe1JIUhHWk+WRDao/Mq68gLRO0yaae5DbPuAzZs5sXjksxAcdVntpSjH261K2F+b63G8KhTcZIprGthMgo/uBzFr5AMuOOSmnVUQjziq1XVb4tM+APne/9kugrXtcZN8e1jF1V/ybwYwf+9eOv9Kr7F7XcyV+WfLvsAyFC7faaHmPS+XXxWNPY9GJILuWY3iNNg7aNGXlwpIWvckyiPu9RlRQcaZmz2Y1x2EtN22iyFmInj9XRHYhTVMexRanNE1gaC91jK8TSR156yPdKaanNWf6FWMjfaaXLjpTaSenPC5CTerqb17DGllwyqyy3HEh4qSo3iOw8dVczL9UcyTR6G19npCJfIMzMXv214f4ZdLXeeodyQFmSGRj3f8WzHAol98o4h+bEW693QI4y3fXZiu37i0xNHT/ldTZYNqzCZiv76rDJ1NEuIqfn+G3x7IqsBnyTGLYOiY4UYPOevY8hjy7qT/JAxdaMuhg5opXCWlhxcSHEpSesldXHjHtxjK1XjqkeyiQUFzE+fVKkL8KWCbcZdktmTqpIZrnpaZP76Qu3PR7w7IUCu3fD1fIZmFJgy3WZPfxrwZvhxl+nH/2mmHrnoiJz2UC+vQ+UJq3JuLpfF+sPL+qv2trs8Ys14l36agndS9eaEV3yc2JCRWpPuAuKD5FBLDtujDV7bMzeOrbm0TVg+/uy5kypVUCzmISswPVm+bHJxtzbvjwVFp43w5ekRBVShLAQBjyhnIuSi0ijpy6MOW1CjhJk0mKbz8Qk615v6vuGvtOCuhepzYb+WvFmuPFFlindkYcvU1ZKI0supV1WZ78wFz5vAaQMsfDO6K5tgx4vicctwypUbntznsYONAfDytGvLPFWjLXWuQcziO37C9LiC7z48oL+8z3NSceT4w2NT3zUBdIgDMfC9p3JPHLIwxxLtC2VjqpB6J7a/r07SuhRpA/Wn54aoX1ugpOl2y22wnAkdO/A5vPRbhxeQQV/5nC90H7a0H6qNGdw9NGA30aa755bN1rpQmtzlWEqelGEJjY9su4sA19KmYUUMyXMTBRlZtwf3oxnLyWxu7rYhXKZyTmqevW8Ld8ebld1rkpJUbLqy9wS2kgltBRKaamh65EZXWqE4Zhcj7YMeWyMDGMCES2b94Xlsy3Pjtcctx1BEp80R3Q+kBplOJJR9CEZmaWW12JOxG3zRJWFMd/w4FexDkyR6Gx/H6lrTrkC0D1VVt9/yqIZePdojRPl4/MV3RA4/fCE/jue9jPBDZ5mLfizxqZBi0AUS0JOCDc7jLk+Vu23Cyo/U8LMXFZ7I3gzxr7f7XSX8N720aE56NnFyaV96UDdq2vINfOiE5cU3zORYR6TXbU3PEsqV3njQauH7o+F/khYf6B88OSMZ4sNSYWojqH3uLUnnDna5+a5Cz3WxdHLWwdayahLFX5Ut3cedSTY+E2y422UuBUWnwib33rC+SLx/NkRzudzlLNtha/fH1mCMjxt8YuQue6J1Pp6Pso0Wb/Ok2q2fTV03Wc75j70Olhjxr3jzSTo7ip834eT3Z7zmw7ZE7G+9WzsdcIpI6usqLNAScjlTHk77oklG7rvMkcd6J4K519MxPd7fveTT3jSbPhw/ZSzoSVtPe2p0D6H5XdNbLE5jUZRzaw0azG1BFz31FWjjK1eYNNJyj3lWyWcDbgh0axNLNJvbbLqsApsPvAWITyJVgJUSK0yrMbEoOtDFX8kla1JYenZtFg524wevfSh93sqMpkwo/3w6t2EM26Ft0c3/qYoI3RvWr/dv0FkWql5spH/PTaSHL6hlLC7UMxiC/FpZHHcsfI9XpRNDJz3DeQRx1YvNy302k2mVqJLeS8+rIT+WBiWwnCkxKXCIuJ8zHPK7UYQG8Hl7LwOLpfwxuWOCjNSTldubdU8SRY0WsRSO/F0vPnIoMg27oTuRTKqdraVUzjvzR8EvmeNXZpAFRy8xR7RxiU5nKbKLHNZhCHqIfqKwXUmrliy8v1T5ft/13d5ttjwpNkwJM+nmxWfnq5oP/asPlKacxtZVNpKi0dXJ/Qnnu7E0Z0I2/chLpX+cwOyjKyOOpZtz5lAFx1x6eieOmLrSL7BRWXzjtA/zZNUutwTX+5TXpGQ0EZQHGmhtUuvP7LM/iIlfCxDGQZkG3EvzpEhomdr8+glRJ/7zx8k3g5jT6+YuXW2sS489hsdI5efSv93OZzNJVfq2CbNlFOlUkzNC+bvDlKuvz9bbHja2l59HRvOu4Z+G1hsxRpYYi6nKTUJVnTiuhNH91Toj6F/osRlwh8PNO3AatGxbAa6ITA0EV14G5nsxXiOSeieCf3T3HMexcL1pwltbB5b0w5ssbK8erfTB1974ItH73c9etHue2zjlN42PHhjP0S+uAmMCNKiMSIlU/8yUk0eKiB9RL1HvHlEHXLIm/nmLir0ZX8sdStq2ujZMxfpqZPIP/bO1zmNC/7O88/z2XbJi28+IXzmWXwCzVkiBWHzrrfW1pU9r3sKaaH0TxN6MtAe9XzxnResQs8Xjp6zcKNxfbh6wkerY05PFpwujiCKldccfO7zz/m9zz7m+5Yv+OGjD1lKzxNvUjUf9s94EZf89U9+N//g4/c40xX6aQs9hLVFG+1nA+G0x513yNnaEm55pFKlI3fdy419DunfGB68sQO38xZlD65uTApeQaohZRprTKhzWSst1+GnPV4+Z+aDjNLJWUKqSiznLb06wCufa07p1fOiW/D8fIk/9TRnYmKQ0fb1w9Jkprqnlizr3k3oMtE82fLOkzXvLtf8I0+/Q+sG3g3nNrlFA5vUMKhjOwScKMMzjyos2oFFM/D7P/c7/I9Ovs6PLr/OH16s8Tna2ejAf9d9l28Nz/gH6/f5nfCUs0LeKVn9reI2Odu+7epwRN1sLzawzMb8YPHmSDW1p9l6ownBjDCXbPQQ++oylNFKV72sV5N/S0UWaRIpyKTunyI6kOekCdIdEFtwhWS+9xoxl8xS7lLz1GQaCn/79Pv5aHvCR588oV83hFz/Xn9O2D7zxIWNO04hZ8hDYvlsy2rR8e7Rmg9Wp6x8z8pZpvuT4Yikwqf9ik1s+Pb5E75zekzXefrTFlTYimXr/1+nK3519SVOFh2fP3pBUuFFv6SPnm8/P6HbNuiHC5bfcTw7haMPE2GTWH57a6W1sw2y6cx7b7dGWhqGvZ7zea/+kPFmSTW5t92ILIKqjB1RWeLpOqgz1a5QrNWYkJBvLs0Vk0L6wULfmBCJ+Qax2zSjTS6v7d0EpvLKqTGa7HAkDEtAhd86e5ePz1f0ny2QLqu/eqV7N7e7LhRdRVwTOTrqCD7xfU9e8KTd8P7ijPebs3GZ6nneL1jHhu9sjjnvWz4+O+LssyX0DnfurXU1z1yLnwQ+80d86uDr/vPIIPhzm7nWPBdOtrD8OLH8pK8detINyPMzS771fS2daWErzuSYtwpvNoyfjn8qxucdqIwGdhnHnbzXlj2SzCXjpARQHT34pTeGy2rztYvLOuEO9ZFKMiILGOmlDjwEpBM+fHHCZtNYCS/mbrRA5cprm/CLiHMJ7xPeJbrkOR9anChdCkQVuhTooufjzTHb6PnsbEXXBeJZgzv1uE4I63GogyUMRw4/2E0pnJWpLVbbX3w60DzvkG2Pe7G2ctpmUxuX6nisfRWZGW8F3qyxFzWZ/GESsXC+7APFyU4C6AJErMRWvPqheeYFzpnB+zzo8KYhZ8qqK07RS+SwrW/d1h4XuSkm24Q/d7z49glEsVFKmmvaAmllfe1+EVmuOpxLND7indJHj6pw3rcA9Mlxvm3pBs/6xRLtHO7U4zdCk0cdu94MWaJ13blIHdpQVGBdn2iedzAk3PnWzv96m407kvZn3WXMwxneXjycBF0mwICF5eq81bVF6/8u7Us/JH93aBiFBsukl+cVg99XTzmkMZdvJnoFK69y2TFDF1FcLM0rIBtnAxtyic6eRC3dpSgMg8M529KIKP3gEVFiciQVhsHTbQOpd8iLgO+F5oXDbfO0lrUNTmzOs5FvjcfvtgnfW496UX51Z1vbrmw78+Lb7agD1x826Nmjv714GMbuyxy1MQQXjI5KzB5ZFen7XYPPdV1pW/bHMWsej2yjib0l5vY6sWSYdHNNvFWNEqYQMRnsK/ICLhrNtRhyaoRhqyZioYLvvNFcF7or/DAIqg7tHdsuU3TLTSCJ0VQ7Z2OPe2FxLsgAzZmF6YvnqQ5vCOcR6SfDGcr8tPUWtp3psuc9d4mY0o7QRMpjkK9oJJrxVuKejT2XZg4ZzP7fckOLFrWYGGsprGqJV+EIHUmr+7Pf8zxzxSHB79I4yYY9YMqxJWwtM9WL0btifZPjZV03+9t4wNIoIxEr5xWCTd4/O7IIBUASK+cNYkbtFE2TjjIVGCRPdhH8RoyZtyYbe/biZ9nQ1wP+rLemlXXHdEiibrbQd5m33h+OkuqJmfvKvxdxv8auWAbe7Sq/InJheIDkv4tP5ij9FR4+eyuVMjfcHosz8gvBWbY/5L12prtWddQSxqsa/bNMYc2z0LUk5NykRCdizSlZfkqzvtulb30yHNF1hZxDJqRT55yX4Q6lp72MQfZbm8TicwebRAjnMYfoox58NfKteebKV+/6Xa23QiWey2WPBvfv2WPcGRRRMR3hrLpjWOKdleV8QjSh0e0m7UqWWBzqszb5/muI9WLXKEDVjHiKqPUmpN7nG4Qz+qh3WXMOC42LWkvRdivkmRJ+771tW0P+Vkg3eecwHYHst7pj5KNMdBaGzCq11lo67Ibq2wHpeph6767PvIUDVNa5++xR4Z49u1bFkrovzh60elRXjM1C6eLrJUY0BEjR6uXTKKCQauQK11ofnI0e447rwS0FVV+t9KuXMckSlbApvd9SxyVDJunl+ehl4b4DnCJRcD2UXnf7vmvYJcEnOhGtGHL2vMxQizpRhhlylSDZMIauN3bbdNRxlYrKhp2u4BjM+J7GGwjjBwu5wQQdVSkDxUTNwKZevtpNDtE1CyXKXm1dXsKgq0sQTFOuGPTkOCrUoQqpEfsedjPwJq4IJM3qNTLu2fPzRbWKWPg+G28Husnlua2yo0KTS2LT81SGM7iq8qqjdHUelFjkouoghk0unWV5rsPTb9Ls0R8p3mw2XtWYbWD18UOYDmwYclmuRAT7tNerXipLH6t3tW005TDd/k/uG7fjp0D15iVMR4yRlrxY7q52vO1FB9kjVwJLD+ps5LGL5JHHWptlSr98EXCsib7SP65lfloaw/as5yZJq4KrxoknnzFjD2/W2LNunBIukYAgJ8J83d+CZc4rm2u45gfbMQ4wXPg6Bkmz9HOdeZ6TaGkv4VYSbK6HsN4NyWV/CTX8TsiZZq14u8nIkPvBh2QCjZP1q3N5iPr0WHuU3N7IL1Wmuc5Gy+XDvs9Pm7PpM3bx5uvsL/PMJZx3Ju1c6sEiuQdNdrP49eey/5+U0Myz59DbsWPoowS0fT+YbJsm2PJeG3SH01NGILk+ZS32rKOeddZlUNzWjF02uyw18R4lXKTiTk9RFW+cUFg1RzgvU+VJOpNiHjHevLFfF4UKm1xOPmVm3TSjnum2OEGXizxk0bTkUuPrHj0F8+ixzVpuYVeyCRjr4zlxps5szvdaxyW5nLyTE7szmCqszT8Pp0ZFlW2H9IPprS9aJNNSiclkr6eTYhctHK9qyQ+o+/OKfhg9et/vMv+uQsnGzx7/0eLhGPuU9nrZBzITWnBu5NLvY+LRa7Z9yqybsmdlLJnt18hdprBaX7qCjjTXOoNcJl6+PHYiq0w/IJsOhqGOKpYhjky2XBarCH703IncSDNyAAAbxFAHXN4gZzH3mj96PAxj11IqmjS0XHjMDT6oOcytNwNVnGbjdFI9tduauGLKajIVZeswIc7FhjocMS7yhFWxx7oI4VxpzhPhxRbZGolFYsrS1N5KiXktmqWcCslF2rYOkASsJ4CYqbITam9JxJXIprzdfTWfQ+W1OQP/6PFAjF3RlGqJ7WAjyisck5zp15CpqnnfLpqZbDHrsHdS9+oFpaw2ne1WknSp2b0ZVdLLJte++8GMU9X05/3eaU6xhuK1+WdvnrwZ+STSSZkoE0eBj4qZMDPjGrh/Us1kXK/s96Lf+HC6y6Tz3kpR/pLIYEiWzytr2OaJKntrUCf0T1sbltA64sIy8663sH06ipnMe7cBjpncMhzYG8f89yFPrimU3DwskUVrjTalBDkdpKFqXWnFo2dDr2W2udQ24xq4V2NXzbPY6quH3aEON8VNZKJVs55coZfucutlmIwrCp7UvoN661IbVpnK2pkXN+acjMMSBkW2il/HS8UxJWbSy+QmUOa/S9uii9bC/WCZwHJDqsMSMxlpXLPOaq4zboT7D+N3mGKHGF65rOQu2btfddxiGE7GYxdSTvk95ccmG2dUvCbDMA6czDx4G+lkXz7a6GVRqvycJfUE1yXrG+/jLhMOMllmUhYrxim5LOj8KOKx03uvI821kGUm71WLgs+hbPzc3DLjAO4/jJ+OBXKC0Oz8n2EYS2iHwvFDh82NH3gPbYOkZDVrn+vqwYy9ElhKSJ1VUsm6ahICrJZI8DZo4djZjLZjG9TYPo/goHviK8NOotJ0iebjDa4bLt7AUrKIouvtC8wYJU+KDR5dtJWvD7lWX2ambbbj8ybvtUZJc4Z9xjVxB5mwWyJp9U7T/vSdr2tgOin0wnPkYkKt5g+KMkv2uNI0aBOsBp8ntyJAgrCJuG2qJbmqL5eonWcHFjb5StXQqeIafjdnkCbPKQIT5Xn7523GjBvgfj27CNK0O38qI4Os/1zQEPJ44Lz/9f5y3nxBjOblvEfaZpSMPrSEckPoehNzyOUvAFZL+i9/juE4sHnX2XDDYAm45lxpf+c5ugjE5VPiQiotwG8jstna+8m18rpFKHXxvke7HgkBOV6Y1t7RcndS7JDGkl3RgLvsZucEyf35s6rMjOvg/vfs+5nvGK1FNUbAj0oz+17+Zft3NSqoxoRcIKvvIU0850T3TpqG4TgwnPg8b90eXltPN8ZJd4Oi5cwpeR5cpEpXTda046XLTSXkrHvwNqJp8vgdqayXZdnLuRQHOifqZlyNaxm7iPzrwL+EBa5/C/gXgC8CvwC8D/wq8GdVtbv0IGSDCmFkgBWkVKmcAqPkM9S/3br+LmOHmxSm2mJhN5q2QZYL4ntPOf9Cw7CSOtjQr7OghEL35fdrJ5zrTcTRRcWdduh6Y167DL/Ibad12KETZLWyMlsTRpINY4cbkyRcJd7sq7zqZO5dkXSea+ozroGXWo+I/ADwrwI/pqq/D1OF/DPAnwP+vKr+MPAJ8FMvfbUi/bynIqNF1KJIKJUyUzGU8nUb5Kx8UZ4hWMgvixY5PiI9O6Z/d8n2XUf3TKrn9ltl8cKMa/PBgu17Ta2x+00knPbm8bdbM8xSeitrL+9DxF6raaoYpk4YfrWSUH6fDkvM8s1lxjkwsuRmQ59xTVzXVQZgJSIBOAK+Cfwx4Bfz/38e+GfuYkGWLEtjAqok0q7ak4qVsMTJWK7ae3zpeBuTYg5dLdCTI+K7x3QfHLN9LzAcmea7TnnvyZh2w9KoskV33W8jsu4t9C7iGTnrrkN+H2VaTdPAaokurZ6Od2OfetHNL+y4uXY+4zXgpWG8qn5DRP494LeANfB/x8L2T1W1sDy+DvzAbRejqjZjLUa0aRDGRJ1qMIM5xLhzziIGGGWv9rPVzkQtVRQXvNXJlw3aeDYfrDj/fKA/EbqnpjKz+CTPMo9m9LGB7ongt7D4OOE3EXe2Rc43xpoLwcQjcqKuZt1DQIKD5YJ0vNq5vRZyj2TO+4523Jxtn3HHuE4Y/y7wE8APAd8PHAN//LovICJfEZFfEZFf6XRd/oh4P35Nu9Iq+SXtlOUOHDj3stv89enx9vvbrbut9LEb+w3v0MaTWk9cWeY9LvNTirJrKa9N+tjdoPg+4bpMfd2POsqWI5NmJHhomsyRH3vr7T3qmHEvSblaPtwj0kxRut3mDPyMG+A6Cbp/Evj7qvoRgIj8JeCPAO+ISMje/UvANw49WVW/CnwV4Fn4QAHzwlP9dt2Vhy4eXnPpbYdSW/ra8Yhz4yAJN3aIFRFLAHWuKtSkxuFiMuVYEeKqYTjyrN9znH1JMe03G3YoA8hgnXLJm/E350qzTvjnHW7T5UkqEyKN5oSciOUDQkCPV8Z7D25Utx2S1dOnfPkYd9peLyTmCpLOpbYZr4Tr7Nl/C/hDInIk5oJ/HPg14K8Cfyo/5ieBX7rZK0v9Kp79qims9Tn2wPolEw9/gaCSUfTl7GeBYIm61NpXbMWGK+ZmF9fvyk2pk9zZZtrtEicNLZMb1I4BFmENb3x3nUplQ1W0KaU5rbmGUUdOp5n3+mZmjz7j1XCdPfvXROQXgf8WGIC/gXnq/xvwCyLy7+S//YWXvppqJZbsGKWTcYRT8fA5iSYh5H1vNpxpyaoYvE/Zw0e4LLeVwJFQEbpn5mk373r6I2E4BolCOBdOvm5GvSNy4c2rLz/aINuIrLs85FGgaayKkJtUZLW0ZOFqiQaPLsLY3JKFIosqLPmmYV48e/cJNXYHc9PLjFviWnV2Vf23gX9778+/CfzBm7yY5uYOVUX2JSarqISNeMK52uNt3/04v80OtlN7FxELzy/b56rajSAIcelJrWRDzyw5NY++eG5NLcMyN8N4M3YZFP98s9Orbq8v0FPZftI02Zv7esOyNSfoS/iexoRcocPWKsRhHblZaWbGbfFGhkQIoGlCgS2GPenxfmlIX0ZGlUESxSGWEtgBPrwMyWx+YWW0lNVnwgZ8J/i17c9pXZWpcoMinfHiZdPVLrQLCMGikEVr76Hs0zNDrkpZDdH2+joZzTQMNjX1EGGmnru5k23G7XDvdNk6LXWnr3tMqF1QbLkKxcvnerbAxYx3eY1kqq4JU5oxYzc2XDhXmtOxnp4mjXi+zzPW1gNsu0tr4BKCZd0XLXhHWu6RhzKrTvphd5pqHo+se73q8wz0GXeNNyJLpUVjrfR0H4JMPH25GewPhLwsZIc8nNHtpiBVqyQVwmS+GrSnCfXQr2wiTBnN5HolrKPts8twin2DLz3z3mUqbGbreRmHOwxlomock3EldJ/D8xn3gDejQZeiRaXOX65U43NyrnS9eW9NJlNSClxu8JkaW71rssSYleHyPjwqPkH7IrH6cEP/pGH9niMFoTkf+e/NJxukG2wdZb99IfPu0LapHt3GSAkyDLWbjfXmYHltHugw4z7w5gQnRXbntdW/Z+Ms5JjCaS9eesonL99L6YqcoS9e1rmqAGtkGr8TWovmlnQZJ7LuEmiyhy/Z85IQTHlYRTmWd6N+nBv36bXjLV4sr13o4X/V/XmdEX9g61OOM99MZvCGjF3KxNV9Y8/0UmOeTYyntIM2OXlXBifENO6BT89s7//kJIfSvhJZUmM3CpUFaZGHSJpyNQgMS2HzwcI63dT26e1pIpzbsAdZb+1mUHrVwV6/VAjahtQGCNmjkwUycjQh0fbqpQPuAmFmv6x2TeMskY/sD8soKF13MxFnBm/Ss1+2Vy8km0xCqeW2PVIKQNFp0xxWq6qNiHLOZqs7qfvz5B0usNs/TvmfZeirdnzuX3f9ZPY545SWOk6qRA8+E3VKchCyHNW00eXy8torldUymUhKo82hpGZut9WSH5l73h813kyCLgslylROeX++egmNnatqLkVDrhpgP1Qmm2XDg3WVNQFtQ/bstgcHTDW2EeLCvlIDGrARUA113JOLVld3/YHkWR40CdgAiML+6/NQB4A0mee23pr01baz8lqMpH3izB21qdZhEaWVeLrszC6c+98fL96MZ1cFjSge8dS2053a+mTvXb1xnXiSJsSU/MF1+YbRBEvC+XEfXp6vUKe/aIDUmqGXfb31qGtta7VQfG/tk7Keukm2P3t/XM6+95lS2w8jw6569tdkbFkERA6F9E4AjxDnkv0jxcOYCDPFNDG3h6roUhhsZTSSd+CX0NjeWRtPCpPhiHFS0x9s3LJ6zTcEqpacacDnLPww6bgrCcK6xr0tRTKuu6aUNe7UCDi5ll7Vau4bOXIqmn5z1v9x42EZ+9Sb7+/pE9XIK121fHhzea6UvlIO38sx3DD5kIvi+0yeCSB+bHhBwXe54WVIuCFZYm8aEjvZ9eiYoTPEkcmXUiXgFJbcwaaWe0AhKSlcf6DGjO9JvBljL/vcW4x+qsfJWXttgmXFs0eviq3J6mvV40YlbFztU5couQMNXJeNfavW3lq2DW5/e5F/rjeJSRmwDJ8oIft9wrmL/fx5oAQ5T3Jv89kPJVNnvFG8mdLbZaWim6IINzaBtDLVmXgUrCV1SJZwG3KyLCbcZsgZ8yNi64hLNw5wzCKSi08GXJ9wm74mBKcDHHbeR8kdlN/zOOad2en3uEE+NByySGWn0ll3H3B+N0E4l/4eBO7f2Ev/+T6m89kvgxNIoN4hMe3U3y0p52prqmXWdfwqmuzO4dcDMngk6liDd4LrFb8xY7f6+EvWMxWJBMqQiqqhN92nVzHJOzL+qdBHSgdzHOND34CRleGVMx4M7n9IRDigI1c6vzRTZA/BgeLBg2QNudQGdGHJuLi00pJERVRxWzNWtxlw2zx66cUZAOH03HIDTbAbRq6JW0It5wPcgRvSPvaNaBiqR98fzWTNLnfr3XTo67GnkEJKuicUklR9fymi+ze18r6dkYBmZdz7xxsfElGRtdWvfq590xwZWA0919IbZz3pMe/RkyXZiqqMFJEITeg2i0IW7n2Wa95B0x4mqlyBWucuE1anhv06FGZqriDu/VnuZpt0XRQ25JS4c8l7laJOpDKXAO8Zb2Cw41AJHhWF1qlq4g9g+nKHPq8yyYaXY2Qjl6i4zhJkbj1YKN711j++7Ua6aiH1FHZe2hN3dGJJtkOh8ZQItI+Yal/6+Lfcl37bT3YW1Sy4khyTz/MOXqMX1aE3Np8TcKEO/Dj42HIznC393vEGRjYXDz754Oa9rkAVt6C5YmmZlloz7ll/XZLa2OQh2UTVwYydbZentfYm95zDTb1EAcrWqRfLf1hyUcLh/Wjx7BeosHdgaPtJTRG1UPmyaOE+Q+RMksJlrj5c3o9fHjvj3vHw+tnzUAgp7LgrQnvRzHBTcKl49H5MxuXsuF4hOnHpGmNE9IBBl7194epP9/aHtgOzB5vxQPCw+tlTMnqpVzPWErJfVvrKobvmzlTpE3K2MSMvQhHbDl2bXv2NstLpclppiQhkb19vUcNMXJnxMPHw+tkLJoMTZEiTsL1EBRNZ5vx4GRKyNR566R23+WjT8tgdJso07Uakr9GLa1JEXnPC75Yoa7w34s6MG+HN9bNflS3O2ukiQ1WjUe/GBNUm7o53KiWzGNGz850EkfYD2l85XPaVca9ePEX0oZeq3oY1PmI8LG78FJrQJLZ3T0ZprQm5YS/bG9PIQZ9OOoVZa33GjIw3189eWjEv8/BZiFFjhC2W5R2sLFclmCePLWW1tNnuhtMPLNR9rcikpZmwMuMQ3lw/O3mPd1k0r2l3uktMVLPdaxnVMv30dfaKvw0owyTxczg94wIeXBhfBiNegHPGhoM6WWZ80ptpH50x423CgzL22op52f/vcS0zZnyv4UEZ+7Ux0y1nzLgx3kpjn3ujZ8y4OW7W1jVjxoy3FnKfiS0R+Qg4A75zby96N/gcb9+a4e1c97zm2+F3q+oHh/5xr8YOICK/oqo/dq8veku8jWuGt3Pd85pfH+YwfsaMR4LZ2GfMeCR4E8b+1TfwmrfF27hmeDvXPa/5NeHe9+wzZsx4M5jD+BkzHglmY58x45Hg3oxdRP64iPyGiPw9EfmZ+3rdm0JEviwif1VEfk1E/raI/HT++3si8t+IyN/N399902vdh4h4EfkbIvJX8u8/JCJfy+f8PxGR9k2vcQoReUdEflFE/gcR+XUR+cNvyXn+1/Nn478Xkf+riCwf+rmGezJ2EfHA/xH4nwE/CvyzIvKj9/Har4AB+DdU9UeBPwT8y3mtPwP8sqr+CPDL+feHhp8Gfn3y+58D/ryq/jDwCfBTb2RVl+PngP9KVX8v8PuxtT/o8ywiPwD8q8CPqervw2SS/wwP/1xTp4u+zi/gDwP/9eT3nwV+9j5e+w7W/kvAPwX8BvDF/LcvAr/xpte2t84vYcbxx4C/gknzfQcIh67Bm/4CngF/n5wknvz9oZ/nHwB+G3gP6y35K8D/9CGf6/J1X2F8OUEFX89/e9AQkR8E/gDwNeALqvrN/K9vAV94U+u6BP8B8G8yzpZ9H/hUVYtQ3kM75z8EfAT8x3nr8R+JyDEP/Dyr6jeAfw/4LeCbwGfAr/KwzzUwJ+guhYicAP858K+p6vPp/9Ru3w+mZikifxL4tqr+6pteyw0QgH8c+A9V9Q9gPRM7IftDO88AOYfwE9jN6vuBY+CPv9FFXRP3ZezfAL48+f1L+W8PEiLSYIb+F1X1L+U/fygiX8z//yLw7Te1vgP4I8A/LSL/APgFLJT/OeAdESltzA/tnH8d+Lqqfi3//ouY8T/k8wzwTwJ/X1U/UtUe+EvY+X/I5xq4P2P/68CP5IxliyU0/vI9vfaNICIC/AXg11X135/86y8DP5l//klsL/8goKo/q6pfUtUfxM7t/1NV/3ngrwJ/Kj/soa35W8Bvi8g/mv/048Cv8YDPc8ZvAX9IRI7yZ6Ws+8Ge64p7TGz8CeDvAP8/4H/7ppMVV6zzf4yFjv9f4G/mrz+B7YF/Gfi7wP8DeO9Nr/WS9f9R4K/kn38P8P8B/h7wnwGLN72+vbX+Y8Cv5HP9XwDvvg3nGfjfA/8D8N8D/xdg8dDPtarOdNkZMx4L5gTdjBmPBLOxz5jxSDAb+4wZjwSzsc+Y8UgwG/uMGY8Es7HPmPFIMBv7jBmPBP9/sa5ekk8Ks88AAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:19.969012Z",
          "iopub.execute_input": "2021-06-02T08:00:19.969335Z",
          "iopub.status.idle": "2021-06-02T08:00:19.977310Z",
          "shell.execute_reply.started": "2021-06-02T08:00:19.969307Z",
          "shell.execute_reply": "2021-06-02T08:00:19.976258Z"
        },
        "trusted": true,
        "id": "2ozrJgGAGYkK",
        "outputId": "9b82bd7d-cfd6-4e32-bb8b-a9426a02acbb"
      },
      "source": [
        "info"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([6., 4., 4.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:32.339732Z",
          "iopub.execute_input": "2021-06-02T08:00:32.340194Z",
          "iopub.status.idle": "2021-06-02T08:00:32.365802Z",
          "shell.execute_reply.started": "2021-06-02T08:00:32.340154Z",
          "shell.execute_reply": "2021-06-02T08:00:32.364476Z"
        },
        "trusted": true,
        "id": "ELcrdHw6GYkK"
      },
      "source": [
        "class TestToys(Dataset):\n",
        "    def __init__(self,data,channels=3):\n",
        "        self.data=data\n",
        "        self.channels=channels\n",
        "        self.transform = A.Compose([A.CenterCrop(width=69, height=69),\n",
        "                                    A.Resize(96,96),\n",
        "                                   A.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))])\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.data[('test', 'dat')])\n",
        "    \n",
        "    def __getitem__(self,idx):\n",
        "        \n",
        "        if self.channels==1:\n",
        "            image = self.data[('test','dat')][idx][0]\n",
        "            \n",
        "        elif self.channels==2:\n",
        "            image=self.data[('test','dat')][idx]\n",
        "            band_3= np.zeros((96,96))\n",
        "            image = np.dstack((image[0],image[1], band_3))\n",
        "            image = image.astype('uint8')\n",
        "            \n",
        "        elif self.channels==3:\n",
        "            image=self.data[('test','dat')][idx]\n",
        "            band_1 = image[0]\n",
        "            band_2 = image[1]\n",
        "            img=torch.tensor(image,dtype=torch.float64)\n",
        "            band_3  = Sobel()(img.unsqueeze(0))\n",
        "            band_3 = np.asarray(band_3[0][0])\n",
        "            \n",
        "            image = np.dstack((band_1, band_2, band_3))\n",
        "            image = image.astype('uint8')\n",
        "            \n",
        "        \n",
        "        if self.transform is not False:\n",
        "            dict=self.transform(image=image)\n",
        "            image=dict['image']\n",
        "            \n",
        "        label= self.data[('test','cat')][idx]\n",
        "        image=torch.tensor(image)\n",
        "        label=torch.tensor(label,dtype=torch.float32)\n",
        "        info = torch.tensor(loaded_data['test','info'][idx][1:],dtype=torch.float32)\n",
        "        info[0]=info[0]#*5 + 30\n",
        "        info[1] = info[1]#*10\n",
        "        info[2]= info[2]#*1\n",
        "        if self.channels>1:\n",
        "            image=image.permute(2,0,1)\n",
        "        if self.channels==2:\n",
        "            image=image[:2]\n",
        "        image=image/255  \n",
        "        return image,info,label.long()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:34.731224Z",
          "iopub.execute_input": "2021-06-02T08:00:34.731550Z",
          "iopub.status.idle": "2021-06-02T08:00:34.735718Z",
          "shell.execute_reply.started": "2021-06-02T08:00:34.731519Z",
          "shell.execute_reply": "2021-06-02T08:00:34.734461Z"
        },
        "trusted": true,
        "id": "i-EgUnpiGYkK"
      },
      "source": [
        "benchmark=TestToys(loaded_data,3)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:35.726011Z",
          "iopub.execute_input": "2021-06-02T08:00:35.726348Z",
          "iopub.status.idle": "2021-06-02T08:00:35.849016Z",
          "shell.execute_reply.started": "2021-06-02T08:00:35.726318Z",
          "shell.execute_reply": "2021-06-02T08:00:35.848023Z"
        },
        "trusted": true,
        "id": "aJl6CHKcGYkL",
        "outputId": "79aa2d35-2b71-4ba1-9d60-92c363d9d69e"
      },
      "source": [
        "image,info,label=benchmark[0]\n",
        "plt.imshow(image[2])#.permute(1,2,0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7efc712bbdd0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:38.396999Z",
          "iopub.execute_input": "2021-06-02T08:00:38.397347Z",
          "iopub.status.idle": "2021-06-02T08:00:38.402742Z",
          "shell.execute_reply.started": "2021-06-02T08:00:38.397316Z",
          "shell.execute_reply": "2021-06-02T08:00:38.401843Z"
        },
        "trusted": true,
        "id": "lhVdvEoKGYkL",
        "outputId": "cee158b5-dfbd-4118-d8fa-727a6af9922f"
      },
      "source": [
        "info"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0., 0., 0.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:18.320125Z",
          "iopub.execute_input": "2021-06-02T07:31:18.320442Z",
          "iopub.status.idle": "2021-06-02T07:31:18.333556Z",
          "shell.execute_reply.started": "2021-06-02T07:31:18.320409Z",
          "shell.execute_reply": "2021-06-02T07:31:18.332650Z"
        },
        "trusted": true,
        "id": "kUMjjSAKGYkL"
      },
      "source": [
        "train_length=int(0.50*len(dataset))\n",
        "\n",
        "test_length=len(dataset)-train_length\n",
        "\n",
        "train_dataset,val_dataset=torch.utils.data.random_split(dataset,(train_length,test_length))\n",
        "train_length = int(0.75*len(train_dataset))\n",
        "test_length = len(train_dataset)-train_length\n",
        "train_dataset,val_dataset=torch.utils.data.random_split(train_dataset,(train_length,test_length))\n",
        "batch_size= 64\n",
        "trainloader = DataLoader(train_dataset,\n",
        "        batch_size=batch_size, shuffle=True,num_workers= 2)\n",
        "valloader = DataLoader(val_dataset,\n",
        "        batch_size=batch_size, shuffle=True,num_workers=2)\n",
        "testloader = DataLoader(benchmark,\n",
        "        batch_size=batch_size, shuffle=False,num_workers=2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:18.334853Z",
          "iopub.execute_input": "2021-06-02T07:31:18.335183Z",
          "iopub.status.idle": "2021-06-02T07:31:18.344497Z",
          "shell.execute_reply.started": "2021-06-02T07:31:18.335150Z",
          "shell.execute_reply": "2021-06-02T07:31:18.343008Z"
        },
        "trusted": true,
        "id": "BFB01zNiGYkL",
        "outputId": "3ac356e7-bd84-4aba-e11a-dc4c28a2d0e0"
      },
      "source": [
        "print(len(train_dataset),len(val_dataset),len(benchmark))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9112 3038 24300\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:18.346662Z",
          "iopub.execute_input": "2021-06-02T07:31:18.347177Z",
          "iopub.status.idle": "2021-06-02T07:31:18.403403Z",
          "shell.execute_reply.started": "2021-06-02T07:31:18.347132Z",
          "shell.execute_reply": "2021-06-02T07:31:18.402469Z"
        },
        "trusted": true,
        "id": "IZYnBbdrGYkM",
        "outputId": "97f8439f-c243-45fc-d7a4-536c26991780"
      },
      "source": [
        "device = \"cpu\"\n",
        "\n",
        "if torch.cuda.is_available():\n",
        "    device = \"cuda\"\n",
        "\n",
        "print(device)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:26.229415Z",
          "iopub.execute_input": "2021-06-02T07:31:26.229770Z",
          "iopub.status.idle": "2021-06-02T07:31:33.228193Z",
          "shell.execute_reply.started": "2021-06-02T07:31:26.229735Z",
          "shell.execute_reply": "2021-06-02T07:31:33.227323Z"
        },
        "trusted": true,
        "colab": {
          "referenced_widgets": [
            "77b06da9dbb248688b184f1686aaf98e"
          ]
        },
        "id": "sH5IPBAjGYkM",
        "outputId": "dfad3460-5fdb-469c-c6f5-53d911620b07"
      },
      "source": [
        "import torchvision.models as models\n",
        "model_ft = models.densenet161(pretrained=True)\n",
        "model_ft=nn.Sequential(*list(model_ft.children())[:1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/densenet161-8d451a50.pth\" to /root/.cache/torch/hub/checkpoints/densenet161-8d451a50.pth\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0.00/110M [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "77b06da9dbb248688b184f1686aaf98e"
            }
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:33.229421Z",
          "iopub.execute_input": "2021-06-02T07:31:33.229789Z",
          "iopub.status.idle": "2021-06-02T07:31:33.236778Z",
          "shell.execute_reply.started": "2021-06-02T07:31:33.229756Z",
          "shell.execute_reply": "2021-06-02T07:31:33.235991Z"
        },
        "trusted": true,
        "id": "W1n7rMmSGYkM"
      },
      "source": [
        "class MyModel(nn.Module):\n",
        "    def __init__(self, pretrained_model):\n",
        "        super(MyModel, self).__init__()\n",
        "        self.pretrained = pretrained_model\n",
        "        self.linear = nn.Linear(2211,5)\n",
        "    def forward(self, x,y):\n",
        "        x = self.pretrained(x)\n",
        "        out = F.relu(x, inplace=True)\n",
        "        out = F.adaptive_max_pool2d(out,output_size=1)\n",
        "        out = torch.flatten(out, 1)\n",
        "        out=torch.cat((out,y),1)\n",
        "        out = self.linear(out)\n",
        "        return out\n",
        "\n",
        "model = MyModel(model_ft)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:33.238075Z",
          "iopub.execute_input": "2021-06-02T07:31:33.238579Z",
          "iopub.status.idle": "2021-06-02T07:31:33.254514Z",
          "shell.execute_reply.started": "2021-06-02T07:31:33.238527Z",
          "shell.execute_reply": "2021-06-02T07:31:33.253693Z"
        },
        "trusted": true,
        "id": "uq1XKZcXGYkM"
      },
      "source": [
        "def find_acc(pred, label):\n",
        "    \n",
        "    correct = pred.argmax(dim = 1).eq(label)\n",
        "    accuracy = correct.to(torch.float32).mean().item() * 100\n",
        "    return accuracy\n",
        "\n",
        "def train(network,criterion, optimizer, trainloader):\n",
        "    loss_train = 0\n",
        "    acc_train = 0\n",
        "    network.train()\n",
        "\n",
        "    #for step in tqdm(range(len(trainloader))):\n",
        "\n",
        "    for idx,batch in enumerate(tqdm(trainloader)): \n",
        "    \n",
        "        #images , labels = next(iter(trainloader))\n",
        "        \n",
        "        images,info, labels = batch[0],batch[1],batch[2]\n",
        "        # move the images and labels to GPU\n",
        "        images     = images.to(device)\n",
        "        info = info.to(device)\n",
        "        labels     = labels.to(device)\n",
        "        \n",
        "        pred = network(images,info)\n",
        "      \n",
        "        # clear all the gradients before calculating them\n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        # find the loss for the current step\n",
        "        loss_train_step = criterion(pred , labels)\n",
        "        \n",
        "        # find accuracy\n",
        "        acc_train_step = find_acc(pred, labels)\n",
        "        \n",
        "        # calculate the gradients\n",
        "        loss_train_step.backward()\n",
        "        \n",
        "        # update the parameters\n",
        "        optimizer.step()\n",
        "        #scheduler.step()\n",
        "\n",
        "        loss_train += loss_train_step.item()\n",
        "        acc_train += acc_train_step  \n",
        "            \n",
        "    loss_train /= len(trainloader)\n",
        "    acc_train /= len(trainloader)\n",
        "\n",
        "    return loss_train, acc_train  \n",
        "        \n",
        "def validate(network,criterion, testloader): \n",
        "    loss_valid = 0\n",
        "    acc_valid = 0       \n",
        "    network.eval()  \n",
        "\n",
        "    #for step in tqdm(range(len(testloader))):\n",
        "    for idx,batch in enumerate(tqdm(testloader)):\n",
        "         \n",
        "        images,info ,labels = batch[0],batch[1],batch[2]\n",
        "        # move the images and labels to GPU\n",
        "        images     = images.to(device)\n",
        "        info = info.to(device)\n",
        "        labels     = labels.to(device)\n",
        "        \n",
        "        pred = network(images,info)\n",
        "        \n",
        "        # find the loss and acc for the current step\n",
        "        loss_valid_step = criterion(pred , labels)\n",
        "        acc_valid_step = find_acc(pred, labels)\n",
        "      \n",
        "        loss_valid += loss_valid_step.item()\n",
        "        acc_valid += acc_valid_step\n",
        "\n",
        "    loss_valid /= len(testloader)\n",
        "    acc_valid /= len(testloader)\n",
        "\n",
        "    return loss_valid, acc_valid\n",
        "\n",
        "def inference(network,criterion, testloader):\n",
        "    loss_test = 0\n",
        "    acc_test = 0       \n",
        "    network.eval()  \n",
        "\n",
        "    #for step in tqdm(range(len(testloader))):\n",
        "    for idx,batch in enumerate(tqdm(testloader)):\n",
        "         \n",
        "        images,info, labels = batch[0],batch[1],batch[2]\n",
        "        # move the images and labels to GPU\n",
        "        images     = images.to(device)\n",
        "        info = info.to(device)\n",
        "        labels     = labels.to(device)\n",
        "        \n",
        "        pred = network(images,info)\n",
        "    \n",
        "        # find the loss and acc for the current step\n",
        "        loss_valid_step = criterion(pred , labels)\n",
        "        acc_valid_step = find_acc(pred, labels)\n",
        "      \n",
        "        loss_test += loss_valid_step.item()\n",
        "        acc_test += acc_valid_step\n",
        "\n",
        "    loss_test /= len(testloader)\n",
        "    acc_test /= len(testloader)\n",
        "    return loss_test, acc_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:33.255752Z",
          "iopub.execute_input": "2021-06-02T07:31:33.256219Z",
          "iopub.status.idle": "2021-06-02T07:31:45.293124Z",
          "shell.execute_reply.started": "2021-06-02T07:31:33.256184Z",
          "shell.execute_reply": "2021-06-02T07:31:45.292212Z"
        },
        "trusted": true,
        "id": "RwhQFHeDGYkN",
        "outputId": "be625377-707d-45b6-90fc-2d60fc703964"
      },
      "source": [
        "\n",
        "wandb.login()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: You can find your API key in your browser here: https://wandb.ai/authorize\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: Paste an API key from your profile and hit enter:  ········································\n"
          ],
          "name": "stdin"
        },
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: Appending key for api.wandb.ai to your netrc file: /root/.netrc\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:31:45.298158Z",
          "iopub.execute_input": "2021-06-02T07:31:45.299678Z",
          "iopub.status.idle": "2021-06-02T07:57:19.941265Z",
          "shell.execute_reply.started": "2021-06-02T07:31:45.299632Z",
          "shell.execute_reply": "2021-06-02T07:57:19.940102Z"
        },
        "trusted": true,
        "colab": {
          "referenced_widgets": [
            "c90b6f1c5a40414cb8cade8f785e02f3",
            "2265827f4b7c4bd7b74759ab5c3bec7c",
            "73130ba3ccdd4b34bbfcecb049f5f5c7",
            "eb6ed3592c4e46b69da4f025f4ee78b4",
            "a40db1a659bd4634903da8de1ca9fc98",
            "8de4ee22607a47e3b3f46721c0f6b7d1",
            "b96c521a97bb451ea7da7134d91f5c8a",
            "d3c9e8eee1564956a7d36a55d5402937",
            "e1ab54af80824e9e9dc9b4caf9f0bb94",
            "e1b875c1f5ef443f8a165e3b29965d29",
            "8de54fda86c14a7b9cdadb355de7c7ef",
            "eb4d2466f5fb49f7b2d499f310b8e0b2",
            "d27a0bc6a24849f4b8c809ffceb3a43a",
            "115efc95a1f3412da7db3abfecf150dc",
            "c4529e289b4643b3b94d3035a6108fa5",
            "60c7bdc496ab4186bfe5d67cc6430cfb",
            "9e7ef65ede774a7b8d632926f35ab00c",
            "a6e23fcc6af4422383409a78bdfc52ee",
            "cb62a23bc4b9443297aa80a50720c2ef",
            "f857634f73214cd4a3f3ecfaf6ae8cf0",
            "3a585a1500ce40a99d68fb80f479294d",
            "a9b41f5b994f4b5eac7404d349beb701",
            "8853d8930c3f49de8bc2b63247b18d5c",
            "342ed2301d2b49f384682d7571f5fc22",
            "3812a951bc5d4e56852189361c1f003b",
            "4eac992f4a0a4d19a4a0f6c78d988201",
            "80cdaccc0da240cf85c1b06e076fcc6e",
            "d1000ce1e8d14f51b9d74d2e2d9c4626",
            "d397f659336745608977febe939f0593",
            "339a6f2dc307473a988b6386ebfcee2b",
            "7d0bb1ccfccb4013aaf4711c75893b19",
            "59b5208c2dab4c158c6297b50574ff83",
            "31216b05285a49ea8ed408dd71ad4277",
            "0d8a017878414177ad92b3ca8f577279",
            "c9f68a314aef4cb1b0213de5133e7957",
            "5d964424aebf40a9a4a63fc7899c8e53",
            "2b55c8ba122c400d997586a0f2aa7e1e",
            "fba6744931514da78d0b999ce40c3961",
            "04f96d7af4474f7eaedec689894706e3",
            "5281b0f5e52a4305a12dffe30e0cb6e9",
            "23d5570a7d1846a58fd2399060c9a8f2",
            "2e970bb62eb144dcbb9b7fcf935fff2e",
            "b9ba5aa4cc4c431089fb7e7d1ed96e12",
            "13e4e694fd644f63968f22b8bfdff382",
            "7dbeb64c59d743c9a767ce5551dc0614"
          ]
        },
        "id": "2l-H1OgZGYkN",
        "outputId": "ad192adf-a0b4-4d9f-9c6f-ecf142efeaf6"
      },
      "source": [
        "wandb.init(name='50_SN1_Densenet161',\n",
        "           project='50_SN',\n",
        "           notes='3 Channels with Augs,Sobel', \n",
        "           tags=['SGD','StepLR'],\n",
        "           entity='creganstark')\n",
        "\n",
        "# WandB Configurations (optional)        \n",
        "wandb.config.lr = 1e-3\n",
        "#model=model.float()\n",
        "model = model.to(device)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(),\n",
        "                      lr  =  1e-3,\n",
        "                      momentum     = 0.9,\n",
        "                      nesterov     = True,\n",
        "                      weight_decay = 5e-4)\n",
        "\n",
        "#scheduler = optim.lr_scheduler.CyclicLR(optimizer,base_lr=5e-5,max_lr=5e-4 ,step_size_up=2000)\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer,step_size=9,gamma=0.5)\n",
        "# Log the network weight histograms (optional)\n",
        "wandb.watch(model)\n",
        "\n",
        "num_epochs = 15\n",
        "start_time = time.time()\n",
        "prev_acc=0\n",
        "for epoch in range(1, num_epochs+1):\n",
        "    \n",
        "    loss_train, acc_train = train(model, criterion, optimizer, trainloader)\n",
        "    loss_valid, acc_valid = validate(model, criterion, valloader)\n",
        "    loss_test, acc_test = inference(model,criterion,testloader)\n",
        "    scheduler.step()\n",
        "    \n",
        "    print('Epoch: {}  Train Loss: {:.4f}  Train Acc: {:.4f}  Valid Loss: {:.4f}  Valid Acc: {:.4f} Test Loss: {:.4f}  Test Acc: {:.4f} '.format(epoch, loss_train, acc_train, loss_valid, acc_valid, loss_test, acc_test))\n",
        "\n",
        "    #Log the loss and accuracy values at the end of each epoch\n",
        "    wandb.log({\n",
        "        \"Epoch\": epoch,\n",
        "        \"Train Loss\": loss_train,\n",
        "        \"Train Acc\": acc_train,\n",
        "        \"Test Loss\": loss_test,\n",
        "        \"Test Acc\": acc_test})\n",
        "    if acc_test>prev_acc:\n",
        "      prev_acc=acc_test\n",
        "      acc_test=str(acc_test)\n",
        "      paths = \"test\"+acc_test[:7]+\".pt\"\n",
        "      print('Saving Model')\n",
        "      torch.save({\n",
        "          'epoch': epoch,\n",
        "          'model_state_dict': model.state_dict(),\n",
        "          'optimizer_state_dict': optimizer.state_dict(),\n",
        "          'val_loss': loss_valid,\n",
        "          'val_acc':acc_valid,\n",
        "          'train_acc':acc_train,\n",
        "          'loss_acc':loss_train,\n",
        "          },str(paths))\n",
        "\n",
        "print(\"Time Elapsed : {:.4f}s\".format(time.time() - start_time))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mcreganstark\u001b[0m (use `wandb login --relogin` to force relogin)\n",
            "\u001b[34m\u001b[1mwandb\u001b[0m: wandb version 0.10.31 is available!  To upgrade, please run:\n",
            "\u001b[34m\u001b[1mwandb\u001b[0m:  $ pip install wandb --upgrade\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "                Tracking run with wandb version 0.10.26<br/>\n",
              "                Syncing run <strong style=\"color:#cdcd00\">50_SN1_Densenet161</strong> to <a href=\"https://wandb.ai\" target=\"_blank\">Weights & Biases</a> <a href=\"https://docs.wandb.com/integrations/jupyter.html\" target=\"_blank\">(Documentation)</a>.<br/>\n",
              "                Project page: <a href=\"https://wandb.ai/creganstark/50_SN\" target=\"_blank\">https://wandb.ai/creganstark/50_SN</a><br/>\n",
              "                Run page: <a href=\"https://wandb.ai/creganstark/50_SN/runs/1bfp8oxb\" target=\"_blank\">https://wandb.ai/creganstark/50_SN/runs/1bfp8oxb</a><br/>\n",
              "                Run data is saved locally in <code>/kaggle/working/wandb/run-20210602_073145-1bfp8oxb</code><br/><br/>\n",
              "            "
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "c90b6f1c5a40414cb8cade8f785e02f3"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "2265827f4b7c4bd7b74759ab5c3bec7c"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "73130ba3ccdd4b34bbfcecb049f5f5c7"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 1  Train Loss: 0.1443  Train Acc: 95.3016  Valid Loss: 0.0088  Valid Acc: 99.9023 Test Loss: 0.0871  Test Acc: 97.6936 \n",
            "Saving Model\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "eb6ed3592c4e46b69da4f025f4ee78b4"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "a40db1a659bd4634903da8de1ca9fc98"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "8de4ee22607a47e3b3f46721c0f6b7d1"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 2  Train Loss: 0.0096  Train Acc: 99.8033  Valid Loss: 0.0043  Valid Acc: 99.9023 Test Loss: 0.0656  Test Acc: 98.0701 \n",
            "Saving Model\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "b96c521a97bb451ea7da7134d91f5c8a"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "d3c9e8eee1564956a7d36a55d5402937"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "e1ab54af80824e9e9dc9b4caf9f0bb94"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 3  Train Loss: 0.0051  Train Acc: 99.9563  Valid Loss: 0.0021  Valid Acc: 99.9674 Test Loss: 0.0728  Test Acc: 97.5026 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "e1b875c1f5ef443f8a165e3b29965d29"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "8de54fda86c14a7b9cdadb355de7c7ef"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "eb4d2466f5fb49f7b2d499f310b8e0b2"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 4  Train Loss: 0.0032  Train Acc: 99.9672  Valid Loss: 0.0013  Valid Acc: 100.0000 Test Loss: 0.0644  Test Acc: 97.7478 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "d27a0bc6a24849f4b8c809ffceb3a43a"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "115efc95a1f3412da7db3abfecf150dc"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "c4529e289b4643b3b94d3035a6108fa5"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 5  Train Loss: 0.0027  Train Acc: 99.9672  Valid Loss: 0.0013  Valid Acc: 99.9674 Test Loss: 0.0626  Test Acc: 97.9549 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "60c7bdc496ab4186bfe5d67cc6430cfb"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "9e7ef65ede774a7b8d632926f35ab00c"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "a6e23fcc6af4422383409a78bdfc52ee"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 6  Train Loss: 0.0028  Train Acc: 99.9563  Valid Loss: 0.0006  Valid Acc: 100.0000 Test Loss: 0.0713  Test Acc: 97.4705 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "cb62a23bc4b9443297aa80a50720c2ef"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "f857634f73214cd4a3f3ecfaf6ae8cf0"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "3a585a1500ce40a99d68fb80f479294d"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 7  Train Loss: 0.0017  Train Acc: 99.9599  Valid Loss: 0.0004  Valid Acc: 100.0000 Test Loss: 0.0631  Test Acc: 97.7542 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "a9b41f5b994f4b5eac7404d349beb701"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "8853d8930c3f49de8bc2b63247b18d5c"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "342ed2301d2b49f384682d7571f5fc22"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 8  Train Loss: 0.0028  Train Acc: 99.9563  Valid Loss: 0.0014  Valid Acc: 99.9349 Test Loss: 0.0546  Test Acc: 98.1504 \n",
            "Saving Model\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "3812a951bc5d4e56852189361c1f003b"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "4eac992f4a0a4d19a4a0f6c78d988201"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "80cdaccc0da240cf85c1b06e076fcc6e"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 9  Train Loss: 0.0012  Train Acc: 99.9781  Valid Loss: 0.0023  Valid Acc: 99.9349 Test Loss: 0.0743  Test Acc: 97.2914 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "d1000ce1e8d14f51b9d74d2e2d9c4626"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "d397f659336745608977febe939f0593"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "339a6f2dc307473a988b6386ebfcee2b"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 10  Train Loss: 0.0010  Train Acc: 99.9891  Valid Loss: 0.0003  Valid Acc: 100.0000 Test Loss: 0.0636  Test Acc: 97.7295 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "7d0bb1ccfccb4013aaf4711c75893b19"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "59b5208c2dab4c158c6297b50574ff83"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "31216b05285a49ea8ed408dd71ad4277"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 11  Train Loss: 0.0009  Train Acc: 99.9891  Valid Loss: 0.0004  Valid Acc: 100.0000 Test Loss: 0.0627  Test Acc: 97.7190 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "0d8a017878414177ad92b3ca8f577279"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "c9f68a314aef4cb1b0213de5133e7957"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5d964424aebf40a9a4a63fc7899c8e53"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 12  Train Loss: 0.0010  Train Acc: 99.9672  Valid Loss: 0.0003  Valid Acc: 100.0000 Test Loss: 0.0685  Test Acc: 97.4622 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "2b55c8ba122c400d997586a0f2aa7e1e"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "fba6744931514da78d0b999ce40c3961"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "04f96d7af4474f7eaedec689894706e3"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 13  Train Loss: 0.0009  Train Acc: 100.0000  Valid Loss: 0.0003  Valid Acc: 100.0000 Test Loss: 0.0652  Test Acc: 97.6002 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5281b0f5e52a4305a12dffe30e0cb6e9"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "23d5570a7d1846a58fd2399060c9a8f2"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "2e970bb62eb144dcbb9b7fcf935fff2e"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 14  Train Loss: 0.0009  Train Acc: 99.9891  Valid Loss: 0.0008  Valid Acc: 99.9674 Test Loss: 0.0806  Test Acc: 97.0327 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/143 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "b9ba5aa4cc4c431089fb7e7d1ed96e12"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/48 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "13e4e694fd644f63968f22b8bfdff382"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "7dbeb64c59d743c9a767ce5551dc0614"
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 15  Train Loss: 0.0006  Train Acc: 100.0000  Valid Loss: 0.0004  Valid Acc: 100.0000 Test Loss: 0.0752  Test Acc: 97.1109 \n",
            "Time Elapsed : 1528.2920s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:00:49.687119Z",
          "iopub.execute_input": "2021-06-02T08:00:49.687436Z",
          "iopub.status.idle": "2021-06-02T08:00:49.692687Z",
          "shell.execute_reply.started": "2021-06-02T08:00:49.687406Z",
          "shell.execute_reply": "2021-06-02T08:00:49.691452Z"
        },
        "trusted": true,
        "id": "2NUpbPa_GYkO"
      },
      "source": [
        "testloader = DataLoader(benchmark,\n",
        "        batch_size=batch_size, shuffle=False,num_workers=2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "prT1NAHyGYkO"
      },
      "source": [
        "ckpt=torch.load('test98.1504.pt')#LOADING TNE BEST MODEL I GOT IN PREVIOUS 15 epochs\n",
        "model.load_state_dict(ckpt['model_state_dict'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:09:15.029829Z",
          "iopub.execute_input": "2021-06-02T08:09:15.030145Z",
          "iopub.status.idle": "2021-06-02T08:09:15.058927Z",
          "shell.execute_reply.started": "2021-06-02T08:09:15.030116Z",
          "shell.execute_reply": "2021-06-02T08:09:15.058144Z"
        },
        "trusted": true,
        "id": "EylNA4hHGYkO"
      },
      "source": [
        "model=model.to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:04:23.419003Z",
          "iopub.execute_input": "2021-06-02T08:04:23.419409Z",
          "iopub.status.idle": "2021-06-02T08:05:10.215928Z",
          "shell.execute_reply.started": "2021-06-02T08:04:23.419373Z",
          "shell.execute_reply": "2021-06-02T08:05:10.214860Z"
        },
        "trusted": true,
        "colab": {
          "referenced_widgets": [
            "88165235bd6344fabb492ea36fa81a64"
          ]
        },
        "id": "9LfH96rkGYkO",
        "outputId": "4b4ef245-a555-41f9-ab2c-485268a8d75c"
      },
      "source": [
        "loss_test, acc_test = inference(model,criterion,testloader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "88165235bd6344fabb492ea36fa81a64"
            }
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:06:02.106940Z",
          "iopub.execute_input": "2021-06-02T08:06:02.107306Z",
          "iopub.status.idle": "2021-06-02T08:06:02.114219Z",
          "shell.execute_reply.started": "2021-06-02T08:06:02.107266Z",
          "shell.execute_reply": "2021-06-02T08:06:02.113222Z"
        },
        "trusted": true,
        "id": "8xCqO5gfGYkP",
        "outputId": "6f988adb-df53-4ded-a29d-5935e4f4496a"
      },
      "source": [
        "loss_test,acc_test"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.05355461331323328, 98.19789175924502)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:09:08.310359Z",
          "iopub.execute_input": "2021-06-02T08:09:08.310703Z",
          "iopub.status.idle": "2021-06-02T08:09:08.706601Z",
          "shell.execute_reply.started": "2021-06-02T08:09:08.310671Z",
          "shell.execute_reply": "2021-06-02T08:09:08.705605Z"
        },
        "trusted": true,
        "id": "PZOAsmzSGYkP",
        "outputId": "138b3010-d423-4951-fc66-fb375fff22f9"
      },
      "source": [
        "ckpt=torch.load('test98.0700.pt')\n",
        "model.load_state_dict(ckpt['model_state_dict'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:09:23.921207Z",
          "iopub.execute_input": "2021-06-02T08:09:23.921616Z",
          "iopub.status.idle": "2021-06-02T08:10:10.717170Z",
          "shell.execute_reply.started": "2021-06-02T08:09:23.921556Z",
          "shell.execute_reply": "2021-06-02T08:10:10.716199Z"
        },
        "trusted": true,
        "colab": {
          "referenced_widgets": [
            "1a527c0c77044b8fa0c4a144ebf9af35"
          ]
        },
        "id": "cOtROwW2GYkP",
        "outputId": "a8844bab-159e-493e-e1e3-bc3486c66ee1"
      },
      "source": [
        "loss_test, acc_test = inference(model,criterion,testloader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/380 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "1a527c0c77044b8fa0c4a144ebf9af35"
            }
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:10:17.467448Z",
          "iopub.execute_input": "2021-06-02T08:10:17.467832Z",
          "iopub.status.idle": "2021-06-02T08:10:17.477442Z",
          "shell.execute_reply.started": "2021-06-02T08:10:17.467790Z",
          "shell.execute_reply": "2021-06-02T08:10:17.476626Z"
        },
        "trusted": true,
        "id": "usc6SY4oGYkQ",
        "outputId": "f4a7b966-accb-440d-8dd0-9b73660c5f3a"
      },
      "source": [
        "loss_test,acc_test"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.06365583250819902, 98.2509718913781)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:57:19.943412Z",
          "iopub.execute_input": "2021-06-02T07:57:19.943998Z",
          "iopub.status.idle": "2021-06-02T07:57:25.679966Z",
          "shell.execute_reply.started": "2021-06-02T07:57:19.943949Z",
          "shell.execute_reply": "2021-06-02T07:57:25.676999Z"
        },
        "trusted": true,
        "colab": {
          "referenced_widgets": [
            ""
          ]
        },
        "id": "2u7r2L0WGYkQ",
        "outputId": "728275ca-7da0-46cc-961d-9477c65bd828"
      },
      "source": [
        "#TRYING TO FINETUNE FURTHER WITH LOWER LEARNING RATES\n",
        "wandb.init(name='50_SN1_Densenet161',\n",
        "           project='50_SN',\n",
        "           notes='3 Channels with Augs,Sobel', \n",
        "           tags=['SGD','StepLR'],\n",
        "           entity='creganstark')\n",
        "\n",
        "# WandB Configurations (optional)        \n",
        "wandb.config.lr = 5e-4\n",
        "#model=model.float()\n",
        "#model = model.to(device)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(),\n",
        "                      lr  =  5e-4,\n",
        "                      momentum     = 0.9,\n",
        "                      nesterov     = True,\n",
        "                      weight_decay = 5e-4)\n",
        "\n",
        "#scheduler = optim.lr_scheduler.CyclicLR(optimizer,base_lr=5e-5,max_lr=5e-4 ,step_size_up=2000)\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer,step_size=3,gamma=0.5)\n",
        "# Log the network weight histograms (optional)\n",
        "#wandb.watch(model)\n",
        "\n",
        "num_epochs = 10\n",
        "start_time = time.time()\n",
        "prev_acc=0\n",
        "for epoch in range(1, num_epochs+1):\n",
        "    \n",
        "    loss_train, acc_train = train(model, criterion, optimizer, trainloader)\n",
        "    loss_valid, acc_valid = validate(model, criterion, valloader)\n",
        "    loss_test, acc_test = inference(model,criterion,testloader)\n",
        "    scheduler.step()\n",
        "    \n",
        "    print('Epoch: {}  Train Loss: {:.4f}  Train Acc: {:.4f}  Valid Loss: {:.4f}  Valid Acc: {:.4f} Test Loss: {:.4f}  Test Acc: {:.4f} '.format(epoch, loss_train, acc_train, loss_valid, acc_valid, loss_test, acc_test))\n",
        "\n",
        "    #Log the loss and accuracy values at the end of each epoch\n",
        "    wandb.log({\n",
        "        \"Epoch\": epoch,\n",
        "        \"Train Loss\": loss_train,\n",
        "        \"Train Acc\": acc_train,\n",
        "        \"Test Loss\": loss_test,\n",
        "        \"Test Acc\": acc_test})\n",
        "    if acc_test>prev_acc:\n",
        "      prev_acc=acc_test\n",
        "      acc_test=str(acc_test)\n",
        "      paths = \"test\"+acc_test[:7]+\".pt\"\n",
        "      print('Saving Model')\n",
        "      torch.save({\n",
        "          'epoch': epoch,\n",
        "          'model_state_dict': model.state_dict(),\n",
        "          'optimizer_state_dict': optimizer.state_dict(),\n",
        "          'val_loss': loss_valid,\n",
        "          'val_acc':acc_valid,\n",
        "          'train_acc':acc_train,\n",
        "          'loss_acc':loss_train,\n",
        "          },str(paths))\n",
        "\n",
        "print(\"Time Elapsed : {:.4f}s\".format(time.time() - start_time))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "Finishing last run (ID:1bfp8oxb) before initializing another..."
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<br/>Waiting for W&B process to finish, PID 102<br/>Program ended successfully."
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "VBox(children=(Label(value=' 0.06MB of 0.06MB uploaded (0.00MB deduped)\\r'), FloatProgress(value=1.0, max=1.0)…"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": ""
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[32m\u001b[41mERROR\u001b[0m Control-C detected -- Run data was not synced\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "...Successfully finished last run (ID:1bfp8oxb). Initializing new run:<br/><br/>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: wandb version 0.10.31 is available!  To upgrade, please run:\n",
            "\u001b[34m\u001b[1mwandb\u001b[0m:  $ pip install wandb --upgrade\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Problem at: <ipython-input-22-8a76172c7f54> 5 <module>\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-22-8a76172c7f54>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m            \u001b[0mnotes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'3 Channels with Augs,Sobel'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m            \u001b[0mtags\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'StepLR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m            entity='creganstark')\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# WandB Configurations (optional)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/wandb/sdk/wandb_init.py\u001b[0m in \u001b[0;36minit\u001b[0;34m(job_type, dir, config, project, entity, reinit, tags, group, name, notes, magic, config_exclude_keys, config_include_keys, anonymous, mode, allow_val_change, resume, force, tensorboard, sync_tensorboard, monitor_gym, save_code, id, settings)\u001b[0m\n\u001b[1;32m    763\u001b[0m         \u001b[0;32massert\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    764\u001b[0m         \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"interrupted\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 765\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    766\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    767\u001b[0m         \u001b[0merror_seen\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/wandb/sdk/wandb_init.py\u001b[0m in \u001b[0;36minit\u001b[0;34m(job_type, dir, config, project, entity, reinit, tags, group, name, notes, magic, config_exclude_keys, config_include_keys, anonymous, mode, allow_val_change, resume, force, tensorboard, sync_tensorboard, monitor_gym, save_code, id, settings)\u001b[0m\n\u001b[1;32m    742\u001b[0m         \u001b[0mexcept_exit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msettings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_except_exit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    743\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 744\u001b[0;31m             \u001b[0mrun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    745\u001b[0m             \u001b[0mexcept_exit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msettings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_except_exit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    746\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/wandb/sdk/wandb_init.py\u001b[0m in \u001b[0;36minit\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    523\u001b[0m         \u001b[0;31m# initiate run (stats and metadata probing)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    524\u001b[0m         \u001b[0mrun_obj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_obj\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_obj_offline\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 525\u001b[0;31m         \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterface\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcommunicate_run_start\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_obj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    526\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    527\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_wl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_global_run_stack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/wandb/sdk/interface/interface.py\u001b[0m in \u001b[0;36mcommunicate_run_start\u001b[0;34m(self, run_pb)\u001b[0m\n\u001b[1;32m    781\u001b[0m         \u001b[0mrun_start\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCopyFrom\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_pb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    782\u001b[0m         \u001b[0mrec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_request\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_start\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrun_start\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 783\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_communicate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    784\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    785\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/wandb/sdk/interface/interface.py\u001b[0m in \u001b[0;36m_communicate\u001b[0;34m(self, rec, timeout, local)\u001b[0m\n\u001b[1;32m    531\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrec\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mpb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocal\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    532\u001b[0m     ) -> Optional[pb.Result]:\n\u001b[0;32m--> 533\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_communicate_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrec\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocal\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlocal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    534\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    535\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_communicate_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrec\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mpb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocal\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0m_Future\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/wandb/sdk/interface/interface.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m     80\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     81\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mResult\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 82\u001b[0;31m         \u001b[0mis_set\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_object_ready\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     83\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mis_set\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_object\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     84\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    550\u001b[0m             \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    551\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 552\u001b[0;31m                 \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    553\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    554\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    298\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    299\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 300\u001b[0;31m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    301\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    302\u001b[0m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:57:25.683079Z",
          "iopub.status.idle": "2021-06-02T07:57:25.683798Z"
        },
        "trusted": true,
        "id": "CK2MBXlBGYkQ"
      },
      "source": [
        "wandb.init(name='50_SN1_Densenet161',\n",
        "           project='50_SN',\n",
        "           notes='3 Channels with Augs,Sobel', \n",
        "           tags=['SGD','StepLR'],\n",
        "           entity='creganstark')\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(),\n",
        "                      lr  =  5e-6,\n",
        "                      momentum     = 0.9,\n",
        "                      nesterov     = True,\n",
        "                      weight_decay = 5e-4)\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer,step_size=1,gamma=0.5)\n",
        "num_epochs = 5\n",
        "start_time = time.time()\n",
        "prev_acc=0\n",
        "for epoch in range(1, num_epochs+1):\n",
        "    \n",
        "    loss_train, acc_train = train(model, criterion, optimizer, trainloader)\n",
        "    loss_valid, acc_valid = validate(model, criterion, valloader)\n",
        "    loss_test, acc_test = inference(model,criterion,testloader)\n",
        "    scheduler.step()\n",
        "    \n",
        "    print('Epoch: {}  Train Loss: {:.4f}  Train Acc: {:.4f}  Valid Loss: {:.4f}  Valid Acc: {:.4f} Test Loss: {:.4f}  Test Acc: {:.4f} '.format(epoch, loss_train, acc_train, loss_valid, acc_valid, loss_test, acc_test))\n",
        "\n",
        "    #Log the loss and accuracy values at the end of each epoch\n",
        "    wandb.log({\n",
        "        \"Epoch\": epoch,\n",
        "        \"Train Loss\": loss_train,\n",
        "        \"Train Acc\": acc_train,\n",
        "        \"Test Loss\": loss_test,\n",
        "        \"Test Acc\": acc_test})\n",
        "    if acc_test>prev_acc:\n",
        "      prev_acc=acc_test\n",
        "      acc_test=str(acc_test)\n",
        "      paths = \"test\"+acc_test[:7]+\".pt\"\n",
        "      print('Saving Model')\n",
        "      torch.save({\n",
        "          'epoch': epoch,\n",
        "          'model_state_dict': model.state_dict(),\n",
        "          'optimizer_state_dict': optimizer.state_dict(),\n",
        "          'val_loss': loss_valid,\n",
        "          'val_acc':acc_valid,\n",
        "          'train_acc':acc_train,\n",
        "          'loss_acc':loss_train,\n",
        "          },str(paths))\n",
        "\n",
        "print(\"Time Elapsed : {:.4f}s\".format(time.time() - start_time))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:57:25.688652Z",
          "iopub.status.idle": "2021-06-02T07:57:25.691173Z"
        },
        "trusted": true,
        "id": "5coDzFBvGYkR"
      },
      "source": [
        "wandb.init(name='50_SN1_Densenet161',\n",
        "           project='50_SN',\n",
        "           notes='3 Channels with Augs,Sobel', \n",
        "           tags=['SGD','StepLR'],\n",
        "           entity='creganstark')\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(),\n",
        "                      lr  =  5e-7,\n",
        "                      momentum     = 0.9,\n",
        "                      nesterov     = True,\n",
        "                      weight_decay = 5e-4)\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer,step_size=1,gamma=0.5)\n",
        "num_epochs = 3\n",
        "start_time = time.time()\n",
        "prev_acc=0\n",
        "for epoch in range(1, num_epochs+1):\n",
        "    \n",
        "    loss_train, acc_train = train(model, criterion, optimizer, trainloader)\n",
        "    loss_valid, acc_valid = validate(model, criterion, valloader)\n",
        "    loss_test, acc_test = inference(model,criterion,testloader)\n",
        "    scheduler.step()\n",
        "    \n",
        "    print('Epoch: {}  Train Loss: {:.4f}  Train Acc: {:.4f}  Valid Loss: {:.4f}  Valid Acc: {:.4f} Test Loss: {:.4f}  Test Acc: {:.4f} '.format(epoch, loss_train, acc_train, loss_valid, acc_valid, loss_test, acc_test))\n",
        "\n",
        "    #Log the loss and accuracy values at the end of each epoch\n",
        "    wandb.log({\n",
        "        \"Epoch\": epoch,\n",
        "        \"Train Loss\": loss_train,\n",
        "        \"Train Acc\": acc_train,\n",
        "        \"Test Loss\": loss_test,\n",
        "        \"Test Acc\": acc_test})\n",
        "    if acc_test>prev_acc:\n",
        "      prev_acc=acc_test\n",
        "      acc_test=str(acc_test)\n",
        "      paths = \"test\"+acc_test[:7]+\".pt\"\n",
        "      print('Saving Model')\n",
        "      torch.save({\n",
        "          'epoch': epoch,\n",
        "          'model_state_dict': model.state_dict(),\n",
        "          'optimizer_state_dict': optimizer.state_dict(),\n",
        "          'val_loss': loss_valid,\n",
        "          'val_acc':acc_valid,\n",
        "          'train_acc':acc_train,\n",
        "          'loss_acc':loss_train,\n",
        "          },str(paths))\n",
        "\n",
        "print(\"Time Elapsed : {:.4f}s\".format(time.time() - start_time))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:57:25.692298Z",
          "iopub.status.idle": "2021-06-02T07:57:25.694786Z"
        },
        "trusted": true,
        "id": "_1IqJQQpGYkR"
      },
      "source": [
        "wandb.init(name='50_SN1_Densenet161',\n",
        "           project='50_SN',\n",
        "           notes='3 Channels with Augs,Sobel', \n",
        "           tags=['SGD','StepLR'],\n",
        "           entity='creganstark')\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(),\n",
        "                      lr  =  5e-7,\n",
        "                      momentum     = 0.9,\n",
        "                      nesterov     = True,\n",
        "                      weight_decay = 5e-4)\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer,step_size=1,gamma=0.5)\n",
        "num_epochs = 3\n",
        "start_time = time.time()\n",
        "prev_acc=0\n",
        "for epoch in range(1, num_epochs+1):\n",
        "    \n",
        "    loss_train, acc_train = train(model, criterion, optimizer, trainloader)\n",
        "    loss_valid, acc_valid = validate(model, criterion, valloader)\n",
        "    loss_test, acc_test = inference(model,criterion,testloader)\n",
        "    scheduler.step()\n",
        "    \n",
        "    print('Epoch: {}  Train Loss: {:.4f}  Train Acc: {:.4f}  Valid Loss: {:.4f}  Valid Acc: {:.4f} Test Loss: {:.4f}  Test Acc: {:.4f} '.format(epoch, loss_train, acc_train, loss_valid, acc_valid, loss_test, acc_test))\n",
        "\n",
        "    #Log the loss and accuracy values at the end of each epoch\n",
        "    wandb.log({\n",
        "        \"Epoch\": epoch,\n",
        "        \"Train Loss\": loss_train,\n",
        "        \"Train Acc\": acc_train,\n",
        "        \"Test Loss\": loss_test,\n",
        "        \"Test Acc\": acc_test})\n",
        "    if acc_test>prev_acc:\n",
        "      prev_acc=acc_test\n",
        "      acc_test=str(acc_test)\n",
        "      paths = \"test\"+acc_test[:7]+\".pt\"\n",
        "      print('Saving Model')\n",
        "      torch.save({\n",
        "          'epoch': epoch,\n",
        "          'model_state_dict': model.state_dict(),\n",
        "          'optimizer_state_dict': optimizer.state_dict(),\n",
        "          'val_loss': loss_valid,\n",
        "          'val_acc':acc_valid,\n",
        "          'train_acc':acc_train,\n",
        "          'loss_acc':loss_train,\n",
        "          },str(paths))\n",
        "\n",
        "print(\"Time Elapsed : {:.4f}s\".format(time.time() - start_time))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:03:53.506140Z",
          "iopub.execute_input": "2021-06-02T08:03:53.506458Z",
          "iopub.status.idle": "2021-06-02T08:03:53.886527Z",
          "shell.execute_reply.started": "2021-06-02T08:03:53.506430Z",
          "shell.execute_reply": "2021-06-02T08:03:53.885716Z"
        },
        "trusted": true,
        "id": "29ypsbk7GYkR",
        "outputId": "15256112-c501-4bde-f2e9-36693af7d7a6"
      },
      "source": [
        "ckpt=torch.load('test98.1504.pt')\n",
        "model.load_state_dict(ckpt['model_state_dict'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T08:03:36.086452Z",
          "iopub.execute_input": "2021-06-02T08:03:36.086831Z",
          "iopub.status.idle": "2021-06-02T08:03:36.092377Z",
          "shell.execute_reply.started": "2021-06-02T08:03:36.086800Z",
          "shell.execute_reply": "2021-06-02T08:03:36.091486Z"
        },
        "trusted": true,
        "id": "KgofBjySGYkS",
        "outputId": "9d93f748-63d2-4856-aa9f-4066bfaa3b01"
      },
      "source": [
        "#os.chdir(r'/kaggle/working')\n",
        "from IPython.display import FileLink #-> \n",
        "FileLink(r'test98.1504.pt')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "/kaggle/working/test98.1504.pt"
            ],
            "text/html": [
              "<a href='test98.1504.pt' target='_blank'>test98.1504.pt</a><br>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-06-02T07:57:25.703348Z",
          "iopub.status.idle": "2021-06-02T07:57:25.704225Z"
        },
        "trusted": true,
        "id": "0nJGKo_CGYkS"
      },
      "source": [
        "paths='finalcheckpintsobel1.pth'\n",
        "torch.save({\n",
        "          'epoch': epoch,\n",
        "          'model_state_dict': model.state_dict(),\n",
        "          'optimizer_state_dict': optimizer.state_dict(),\n",
        "          'val_loss': loss_valid,\n",
        "          'val_acc':acc_valid,\n",
        "          'train_acc':acc_train,\n",
        "          'loss_acc':loss_train,\n",
        "          },str(paths))\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}