study_roadmaps/2_transfer_learning_roadmap/3_effect_of_number_of_classes_in_dataset/2) Understand transfer learning and the role of number of dataset classes in it - Pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/Tessellate-Imaging/monk_v1/blob/master/study_roadmaps/2_transfer_learning_roadmap/3_effect_of_number_of_classes_in_dataset/2)%20Understand%20transfer%20learning%20and%20the%20role%20of%20number%20of%20dataset%20classes%20in%20it%20-%20Pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Goals\n",
    "\n",
    "### 1. Visualize deep learning network\n",
    "\n",
    "\n",
    "### 2. Understand how the final layer would change when number of classes in dataset changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What do you do with a deep learning model in transfer learning\n",
    "\n",
    "    - These are the steps already done by contributors in pytorch, keras and mxnet\n",
    "        - You take a deep learning architecture, such as resnet, densenet, or even custom network\n",
    "        - Train the architecture on large datasets such as imagenet, coco, etc\n",
    "        - The trained wieghts become your starting point for transfer learning\n",
    "    \n",
    "    \n",
    "    - The final layer of this pretrained model has number of neurons = number of classes in the large dataset\n",
    "    \n",
    "    \n",
    "    - In transfer learning\n",
    "        - You take the network and load the pretrained weights on the network\n",
    "        - Then remove the final layer that has the extra(or less) number of neurons\n",
    "        - You add a new layer with number of neurons = number of classes in your custom dataset\n",
    "        - Optionally you can add more layers in between this newly added final layer and the old network\n",
    "    \n",
    "    \n",
    "    - Now you have two parts in your network\n",
    "        - One that already existed, the pretrained one, the base network\n",
    "        - The new sub-network or a single layer you added\n",
    "        \n",
    "    \n",
    "    - The hyper-parameter we can see here: Freeze base network\n",
    "        - Freezing base network makes the base network untrainable\n",
    "        - The base network now acts as a feature extractor and only the next half is trained\n",
    "        - If you do not freeze the base network the entire network is trained\n",
    "        (You will take this part in next sessions)\n",
    "     \n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "\n",
    "\n",
    "## [Install](#0)\n",
    "\n",
    "\n",
    "## [Setup Default Params with Cats-Dogs dataset](#1)\n",
    "\n",
    "\n",
    "## [Visualize network](#2)\n",
    "\n",
    "\n",
    "## [Reset Default Params with new dataset - Logo classification](#3)\n",
    "\n",
    "\n",
    "## [Visualize the new network](#4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='0'></a>\n",
    "# Install Monk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using pip (Recommended)\n",
    "\n",
    "  - colab (gpu) \n",
    "      - All bakcends: `pip install -U monk-colab`\n",
    "      \n",
    "\n",
    "  - kaggle (gpu) \n",
    "      - All backends: `pip install -U monk-kaggle`\n",
    "      \n",
    "\n",
    "  - cuda 10.2\t\n",
    "      - All backends: `pip install -U monk-cuda102`\n",
    "      - Gluon bakcned: `pip install -U monk-gluon-cuda102`\n",
    "\t  - Pytorch backend: `pip install -U monk-pytorch-cuda102`\n",
    "      - Keras backend: `pip install -U monk-keras-cuda102`\n",
    "      \n",
    "\n",
    "  - cuda 10.1\t\n",
    "      - All backend: `pip install -U monk-cuda101`\n",
    "\t  - Gluon bakcned: `pip install -U monk-gluon-cuda101`\n",
    "\t  - Pytorch backend: `pip install -U monk-pytorch-cuda101`\n",
    "\t  - Keras backend: `pip install -U monk-keras-cuda101`\n",
    "      \n",
    "\n",
    "  - cuda 10.0\t\n",
    "      - All backend: `pip install -U monk-cuda100`\n",
    "\t  - Gluon bakcned: `pip install -U monk-gluon-cuda100`\n",
    "\t  - Pytorch backend: `pip install -U monk-pytorch-cuda100`\n",
    "\t  - Keras backend: `pip install -U monk-keras-cuda100`\n",
    "      \n",
    "\n",
    "  - cuda 9.2\t\n",
    "      - All backend: `pip install -U monk-cuda92`\n",
    "\t  - Gluon bakcned: `pip install -U monk-gluon-cuda92`\n",
    "\t  - Pytorch backend: `pip install -U monk-pytorch-cuda92`\n",
    "\t  - Keras backend: `pip install -U monk-keras-cuda92`\n",
    "      \n",
    "\n",
    "  - cuda 9.0\t\n",
    "      - All backend: `pip install -U monk-cuda90`\n",
    "\t  - Gluon bakcned: `pip install -U monk-gluon-cuda90`\n",
    "\t  - Pytorch backend: `pip install -U monk-pytorch-cuda90`\n",
    "\t  - Keras backend: `pip install -U monk-keras-cuda90`\n",
    "      \n",
    "\n",
    "  - cpu \t\t\n",
    "      - All backend: `pip install -U monk-cpu`\n",
    "\t  - Gluon bakcned: `pip install -U monk-gluon-cpu`\n",
    "\t  - Pytorch backend: `pip install -U monk-pytorch-cpu`\n",
    "\t  - Keras backend: `pip install -U monk-keras-cpu`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install Monk Manually (Not recommended)\n",
    " \n",
    "### Step 1: Clone the library\n",
    " - git clone https://github.com/Tessellate-Imaging/monk_v1.git\n",
    " \n",
    " \n",
    " \n",
    " \n",
    "### Step 2: Install requirements \n",
    " - Linux\n",
    "     - Cuda 9.0\n",
    "         - `cd monk_v1/installation/Linux && pip install -r requirements_cu90.txt`\n",
    "     - Cuda 9.2\n",
    "         - `cd monk_v1/installation/Linux && pip install -r requirements_cu92.txt`\n",
    "     - Cuda 10.0\n",
    "         - `cd monk_v1/installation/Linux && pip install -r requirements_cu100.txt`\n",
    "     - Cuda 10.1\n",
    "         - `cd monk_v1/installation/Linux && pip install -r requirements_cu101.txt`\n",
    "     - Cuda 10.2\n",
    "         - `cd monk_v1/installation/Linux && pip install -r requirements_cu102.txt`\n",
    "     - CPU (Non gpu system)\n",
    "         - `cd monk_v1/installation/Linux && pip install -r requirements_cpu.txt`\n",
    " \n",
    " \n",
    "  - Windows\n",
    "     - Cuda 9.0 (Experimental support)\n",
    "         - `cd monk_v1/installation/Windows && pip install -r requirements_cu90.txt`\n",
    "     - Cuda 9.2 (Experimental support)\n",
    "         - `cd monk_v1/installation/Windows && pip install -r requirements_cu92.txt`\n",
    "     - Cuda 10.0 (Experimental support)\n",
    "         - `cd monk_v1/installation/Windows && pip install -r requirements_cu100.txt`\n",
    "     - Cuda 10.1 (Experimental support)\n",
    "         - `cd monk_v1/installation/Windows && pip install -r requirements_cu101.txt`\n",
    "     - Cuda 10.2 (Experimental support)\n",
    "         - `cd monk_v1/installation/Windows && pip install -r requirements_cu102.txt`\n",
    "     - CPU (Non gpu system)\n",
    "         - `cd monk_v1/installation/Windows && pip install -r requirements_cpu.txt`\n",
    "         \n",
    "         \n",
    "  - Mac\n",
    "     - CPU (Non gpu system)\n",
    "         - `cd monk_v1/installation/Mac && pip install -r requirements_cpu.txt`\n",
    "         \n",
    "         \n",
    "  - Misc\n",
    "      - Colab (GPU)\n",
    "          - `cd monk_v1/installation/Misc && pip install -r requirements_colab.txt`\n",
    "      - Kaggle (GPU)\n",
    "          - `cd monk_v1/installation/Misc && pip install -r requirements_kaggle.txt`\n",
    " \n",
    " \n",
    " \n",
    "### Step 3: Add to system path (Required for every terminal or kernel run)\n",
    " - `import sys`\n",
    " - `sys.path.append(\"monk_v1/\");`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset - Sample \n",
    "    - one having 2 classes\n",
    "    - other having 16 classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! wget --load-cookies /tmp/cookies.txt \"https://docs.google.com/uc?export=download&confirm=$(wget --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1jE-ckk0JbrdbJvIBaKMJWkTfbRDR2MaF' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\\1\\n/p')&id=1jE-ckk0JbrdbJvIBaKMJWkTfbRDR2MaF\" -O study_classes.zip && rm -rf /tmp/cookies.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "! unzip -qq study_classes.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using pytorch backend \n",
    "\n",
    "# When installed using pip\n",
    "from monk.pytorch_prototype import prototype\n",
    "\n",
    "\n",
    "# When installed manually (Uncomment the following)\n",
    "#import os\n",
    "#import sys\n",
    "#sys.path.append(\"monk_v1/\");\n",
    "#sys.path.append(\"monk_v1/monk/\");\n",
    "#from monk.pytorch_prototype import prototype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating and managing experiments\n",
    "        - Provide project name\n",
    "        - Provide experiment name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pytorch Version: 1.2.0\n",
      "\n",
      "Experiment Details\n",
      "    Project: Project\n",
      "    Experiment: study-num-classes\n",
      "    Dir: /home/abhi/Desktop/Work/tess_tool/gui/v0.3/finetune_models/Organization/development/v5.0_blocks/study_roadmap/change_post_num_layers/5_transfer_learning_params/1_number_of_classes_in_dataset/workspace/Project/study-num-classes/\n",
      "\n"
     ]
    }
   ],
   "source": [
    "gtf = prototype(verbose=1);\n",
    "gtf.Prototype(\"Project\", \"study-num-classes\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This creates files and directories as per the following structure\n",
    "    \n",
    "    \n",
    "    workspace\n",
    "        |\n",
    "        |--------Project\n",
    "                        |\n",
    "                        |-----study-num-classes\n",
    "                                    |\n",
    "                                    |-----experiment-state.json\n",
    "                                    |\n",
    "                                    |-----output\n",
    "                                            |\n",
    "                                            |------logs (All training logs and graphs saved here)\n",
    "                                            |\n",
    "                                            |------models (all trained models saved here)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='1'></a>\n",
    "# Setup Default Params with Cats-Dogs dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Details\n",
      "    Train path:     study_classes/dogs_vs_cats\n",
      "    Val path:       None\n",
      "    CSV train path: None\n",
      "    CSV val path:  None\n",
      "\n",
      "Dataset Params\n",
      "    Input Size:  224\n",
      "    Batch Size:  4\n",
      "    Data Shuffle: True\n",
      "    Processors:   4\n",
      "    Train-val split:   0.7\n",
      "\n",
      "Pre-Composed Train Transforms\n",
      "[{'RandomHorizontalFlip': {'p': 0.8}}, {'Normalize': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]\n",
      "\n",
      "Pre-Composed Val Transforms\n",
      "[{'RandomHorizontalFlip': {'p': 0.8}}, {'Normalize': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]\n",
      "\n",
      "Dataset Numbers\n",
      "    Num train images: 35\n",
      "    Num val images:   15\n",
      "    Num classes:      2\n",
      "\n",
      "Model Params\n",
      "    Model name:           resnet18\n",
      "    Use Gpu:              True\n",
      "    Use pretrained:       True\n",
      "    Freeze base network:  True\n",
      "\n",
      "Model Details\n",
      "    Loading pretrained model\n",
      "    Model Loaded on device\n",
      "        Model name:                           resnet18\n",
      "        Num layers in model:  41\n",
      "        Num trainable layers: 1\n",
      "\n",
      "Optimizer\n",
      "    Name:          sgd\n",
      "    Learning rate: 0.01\n",
      "    Params:        {'lr': 0.01, 'momentum': 0, 'weight_decay': 0, 'momentum_dampening_rate': 0, 'clipnorm': 0.0, 'clipvalue': 0.0}\n",
      "\n",
      "\n",
      "\n",
      "Learning rate scheduler\n",
      "    Name:   reduceonplateaulr\n",
      "    Params: {'mode': 'min', 'factor': 0.1, 'patience': 1, 'verbose': True, 'threshold': 0.0001, 'threshold_mode': 'rel', 'cooldown': 0, 'min_lr': 0, 'epsilon': 1e-08}\n",
      "\n",
      "Loss\n",
      "    Name:          softmaxcrossentropy\n",
      "    Params:        {'weight': None, 'batch_axis': 0, 'axis_to_sum_over': -1, 'label_as_categories': True, 'label_smoothing': False}\n",
      "\n",
      "Training params\n",
      "    Num Epochs: 5\n",
      "\n",
      "Display params\n",
      "    Display progress:          True\n",
      "    Display progress realtime: True\n",
      "    Save Training logs:        True\n",
      "    Save Intermediate models:  True\n",
      "    Intermediate model prefix: intermediate_model_\n",
      "\n"
     ]
    }
   ],
   "source": [
    "gtf.Default(dataset_path=\"study_classes/dogs_vs_cats\", \n",
    "            model_name=\"resnet18\", \n",
    "            num_epochs=5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From Data summary  - Num classes:      2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='2'></a>\n",
    "# Visualize network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using Netron To Visualize\n",
      "Not compatible on kaggle\n",
      "Compatible only for Jupyter Notebooks\n",
      "\n",
      "Stopping http://localhost:8081\n",
      "Serving 'model.onnx' at http://localhost:8081\n"
     ]
    }
   ],
   "source": [
    "gtf.Visualize_With_Netron(data_shape=(3, 224, 224), port=8081);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The final layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename='imgs/2_classes_base_pytorch.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3'></a>\n",
    "# Reset Default Params with new dataset - Logo classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pytorch Version: 1.2.0\n",
      "\n",
      "Experiment Details\n",
      "    Project: Project\n",
      "    Experiment: study-num-classes\n",
      "    Dir: /home/abhi/Desktop/Work/tess_tool/gui/v0.3/finetune_models/Organization/development/v5.0_blocks/study_roadmap/change_post_num_layers/5_transfer_learning_params/1_number_of_classes_in_dataset/workspace/Project/study-num-classes/\n",
      "\n"
     ]
    }
   ],
   "source": [
    "gtf = prototype(verbose=1);\n",
    "gtf.Prototype(\"Project\", \"study-num-classes\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Details\n",
      "    Train path:     study_classes/logos\n",
      "    Val path:       None\n",
      "    CSV train path: None\n",
      "    CSV val path:  None\n",
      "\n",
      "Dataset Params\n",
      "    Input Size:  224\n",
      "    Batch Size:  4\n",
      "    Data Shuffle: True\n",
      "    Processors:   4\n",
      "    Train-val split:   0.7\n",
      "\n",
      "Pre-Composed Train Transforms\n",
      "[{'RandomHorizontalFlip': {'p': 0.8}}, {'Normalize': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]\n",
      "\n",
      "Pre-Composed Val Transforms\n",
      "[{'RandomHorizontalFlip': {'p': 0.8}}, {'Normalize': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]\n",
      "\n",
      "Dataset Numbers\n",
      "    Num train images: 77\n",
      "    Num val images:   33\n",
      "    Num classes:      16\n",
      "\n",
      "Model Params\n",
      "    Model name:           resnet18\n",
      "    Use Gpu:              True\n",
      "    Use pretrained:       True\n",
      "    Freeze base network:  True\n",
      "\n",
      "Model Details\n",
      "    Loading pretrained model\n",
      "    Model Loaded on device\n",
      "        Model name:                           resnet18\n",
      "        Num layers in model:  41\n",
      "        Num trainable layers: 1\n",
      "\n",
      "Optimizer\n",
      "    Name:          sgd\n",
      "    Learning rate: 0.01\n",
      "    Params:        {'lr': 0.01, 'momentum': 0, 'weight_decay': 0, 'momentum_dampening_rate': 0, 'clipnorm': 0.0, 'clipvalue': 0.0}\n",
      "\n",
      "\n",
      "\n",
      "Learning rate scheduler\n",
      "    Name:   reduceonplateaulr\n",
      "    Params: {'mode': 'min', 'factor': 0.1, 'patience': 1, 'verbose': True, 'threshold': 0.0001, 'threshold_mode': 'rel', 'cooldown': 0, 'min_lr': 0, 'epsilon': 1e-08}\n",
      "\n",
      "Loss\n",
      "    Name:          softmaxcrossentropy\n",
      "    Params:        {'weight': None, 'batch_axis': 0, 'axis_to_sum_over': -1, 'label_as_categories': True, 'label_smoothing': False}\n",
      "\n",
      "Training params\n",
      "    Num Epochs: 5\n",
      "\n",
      "Display params\n",
      "    Display progress:          True\n",
      "    Display progress realtime: True\n",
      "    Save Training logs:        True\n",
      "    Save Intermediate models:  True\n",
      "    Intermediate model prefix: intermediate_model_\n",
      "\n"
     ]
    }
   ],
   "source": [
    "gtf.Default(dataset_path=\"study_classes/logos\", \n",
    "            model_name=\"resnet18\", \n",
    "            num_epochs=5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From Data summary  - Num classes:      16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4'></a>\n",
    "# Visualize network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using Netron To Visualize\n",
      "Not compatible on kaggle\n",
      "Compatible only for Jupyter Notebooks\n",
      "Serving 'model.onnx' at http://localhost:8082\n"
     ]
    }
   ],
   "source": [
    "gtf.Visualize_With_Netron(data_shape=(3, 224, 224), port=8082);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The final layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename='imgs/16_classes_base_pytorch.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Goals Completed\n",
    "\n",
    "### 1. Visualize deep learning network\n",
    "\n",
    "### 2. Understand how the final layer would change when number of classes in dataset changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}