week03/Seminar_RandD_Coding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8bab2952-db79-4139-a35c-0e4de926a16b",
   "metadata": {},
   "source": [
    "# R&D Coding "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3ca88987-7ef2-496d-830e-cacbb9edd478",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some imports\n",
    "\n",
    "# computation stuff\n",
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "# plotting stuff\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format='retina' # makes the quality higher\n",
    "\n",
    "import seaborn as sns\n",
    "sns.set_style(\"whitegrid\") # improves the quality of matplotlib images and adds grid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0ecd201-22e3-489b-a799-91a5c42f8ba4",
   "metadata": {},
   "source": [
    "# DNN Training pipeline (for reference)\n",
    "\n",
    "Before we go to the main part, let's reuse code from previous time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1fb87f97-4c30-4d54-a390-82e00bb1759d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader, Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "aa5ca24b-c848-407d-954c-a92e848d47f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchvision\n",
    "from torch import nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e50b1818-3ce1-4716-b1d4-217ee0dc6391",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = torchvision.transforms.Compose( # Sequential application of transforms, for this example it is unnecessarily\n",
    "    [\n",
    "        torchvision.transforms.ToTensor(), # from Image class to Tensor\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "09269806-4dac-4dee-b7eb-d7b264dbe605",
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist_train = torchvision.datasets.MNIST(\n",
    "    \"./mnist/\", train=True, download=True, transform=transform\n",
    ")\n",
    "mnist_val = torchvision.datasets.MNIST(\n",
    "    \"./mnist/\", train=False, download=True, transform=transform\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "93b3be02-435c-45e5-86ab-23bd47e39af2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 28, 28])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 434,
       "width": 417
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "example_img, example_label = mnist_train[0]\n",
    "print(example_img.shape) # C x H x W, 1 channel -- grayscale image\n",
    "plt.imshow(example_img[0])\n",
    "plt.title(example_label)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3102d1fd-9fd2-41fc-a883-4a0d2ddeba8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader = torch.utils.data.DataLoader(mnist_train, batch_size=128, shuffle=True)\n",
    "val_dataloader = torch.utils.data.DataLoader(mnist_val, batch_size=128, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ef116ff8-4d5f-4bb1-95d8-a61495748ba7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FCNetwork(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super().__init__()      \n",
    "\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Flatten(), # reshape input from C x H x W to 1D-vector\n",
    "            nn.Linear(input_size, hidden_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_size, hidden_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_size, output_size),\n",
    "        )\n",
    "\n",
    "    def forward(self, input_data):\n",
    "        return self.net(input_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7fb065e1-04ba-4045-8a52-0af4e55088e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvNetwork(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_channels, hidden_channels, output_size, image_sizes):\n",
    "        super().__init__()      \n",
    "\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Conv2d(input_channels, hidden_channels, kernel_size=(3,3), stride=1, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(hidden_channels, hidden_channels, kernel_size=(3,3), stride=1, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Flatten(), # to do classification we flatten\n",
    "            # you need to calculate the flatten size\n",
    "            nn.Linear(hidden_channels * image_sizes[0] * image_sizes[1], output_size),\n",
    "        )\n",
    "\n",
    "    def forward(self, input_data):\n",
    "        return self.net(input_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6bbeaf59-7278-47ca-88be-bcfbca7101c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResBlock(nn.Module):\n",
    "\n",
    "    def __init__(self, input_channels, hidden_channels):\n",
    "        super().__init__()\n",
    "\n",
    "        self.convs = nn.Sequential(\n",
    "            nn.Conv2d(input_channels, hidden_channels, kernel_size=(3,3), stride=1, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(hidden_channels, hidden_channels, kernel_size=(3,3), stride=1, padding=1),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "\n",
    "        self.downsample = None\n",
    "        if input_channels != hidden_channels:\n",
    "            self.downsample_conv = nn.Conv2d(input_channels, hidden_channels, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        output = self.convs(x)\n",
    "        if self.downsample is not None:\n",
    "            # sometimes output + x won't work due to shape mismatch\n",
    "            # for example if height and width does not match\n",
    "            # or if channels does not match (if we have only single channel it will work though, but in general won't)\n",
    "            x = self.downsample(x)\n",
    "        return output + x # residual connection\n",
    "\n",
    "\n",
    "class ResNetwork(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_channels, hidden_channels, output_size, image_sizes):\n",
    "        super().__init__()      \n",
    "\n",
    "        self.net = nn.Sequential(\n",
    "            ResBlock(input_channels, hidden_channels),\n",
    "            ResBlock(hidden_channels, hidden_channels),\n",
    "            nn.Flatten(), # to do classification we flatten\n",
    "            # you need to calculate the flatten size\n",
    "            nn.Linear(hidden_channels * image_sizes[0] * image_sizes[1], output_size),\n",
    "        )\n",
    "\n",
    "    def forward(self, input_data):\n",
    "        return self.net(input_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d29143a5-b8d5-4437-84e3-8f4df58daedc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FCNetwork(\n",
      "  (net): Sequential(\n",
      "    (0): Flatten(start_dim=1, end_dim=-1)\n",
      "    (1): Linear(in_features=784, out_features=128, bias=True)\n",
      "    (2): ReLU()\n",
      "    (3): Linear(in_features=128, out_features=128, bias=True)\n",
      "    (4): ReLU()\n",
      "    (5): Linear(in_features=128, out_features=10, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "fc_net = FCNetwork(example_img.flatten().shape[0], 128, 10) # 10 labels\n",
    "print(fc_net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1ea6f9d7-a273-40d4-a7a0-2e979676a7c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConvNetwork(\n",
      "  (net): Sequential(\n",
      "    (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): ReLU()\n",
      "    (2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (3): ReLU()\n",
      "    (4): Flatten(start_dim=1, end_dim=-1)\n",
      "    (5): Linear(in_features=25088, out_features=10, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "conv_net = ConvNetwork(1, 32, 10, image_sizes=example_img.shape[1:]) # 10 labels\n",
    "print(conv_net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "47e91486-66a4-42d0-9e58-4dc8eaa5f14d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ResNetwork(\n",
      "  (net): Sequential(\n",
      "    (0): ResBlock(\n",
      "      (convs): Sequential(\n",
      "        (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (1): ReLU()\n",
      "        (2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (3): ReLU()\n",
      "      )\n",
      "      (downsample_conv): Conv2d(1, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "    )\n",
      "    (1): ResBlock(\n",
      "      (convs): Sequential(\n",
      "        (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (1): ReLU()\n",
      "        (2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (3): ReLU()\n",
      "      )\n",
      "    )\n",
      "    (2): Flatten(start_dim=1, end_dim=-1)\n",
      "    (3): Linear(in_features=25088, out_features=10, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "res_net = ResNetwork(1, 32, 10, image_sizes=example_img.shape[1:]) # 10 labels\n",
    "print(res_net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ba20ca7c-35d7-4271-b432-afaa6e78962f",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78455e81-3ba8-4f2d-b5d9-47f83ce43f82",
   "metadata": {},
   "source": [
    "### Training pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9f7b7be1-dfdb-4e9d-b849-d64d5d3dfd60",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "275f0380-6717-4649-a14a-abafdf3c8dde",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm.auto import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a8830132-f614-4fcb-b8da-670686bb18b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_one_epoch(model, dataloader, criterion, optimizer, scheduler, device):\n",
    "    # some layers may have different behavior for train and inference\n",
    "    # this is why it is important to set model to train mode during training\n",
    "    model.train()\n",
    "\n",
    "    avg_loss = 0\n",
    "    for batch_idx, (image, label) in tqdm(enumerate(dataloader), total=len(dataloader)):\n",
    "        # if we want to use GPU for model forward, we need to put inputs and desired outputs on device \n",
    "        image, label = image.to(device), label.to(device)\n",
    "\n",
    "        output = model(image) # calculate model output\n",
    "        loss = criterion(output, label) # calculate loss\n",
    "\n",
    "        loss.backward() # calculate gradients\n",
    "        optimizer.step() # update weights\n",
    "        optimizer.zero_grad() # zero gradients for the next step\n",
    "        scheduler.step() # update learning rate\n",
    "\n",
    "        avg_loss += loss.item() # item to detach loss and get element on CPU\n",
    "        # item is used for tensors containing single scalar\n",
    "\n",
    "    # batch-idx + 1 == the total number of batches == len(dataloader)\n",
    "    avg_loss = avg_loss / (batch_idx + 1)\n",
    "    return avg_loss\n",
    "\n",
    "\n",
    "def evaluate(model, dataloader, criterion, device):\n",
    "    # some layers may have different behavior for train and inference\n",
    "    # this is why it is important to set model to eval mode during inference\n",
    "    model.eval()\n",
    "\n",
    "    avg_loss = 0\n",
    "    accuracy = 0\n",
    "    total_elements = 0\n",
    "    for batch_idx, (image, label) in enumerate(dataloader):\n",
    "        # if we want to use GPU for model forward, we need to put inputs and desired outputs on device \n",
    "        image, label = image.to(device), label.to(device)\n",
    "\n",
    "        output = model(image) # calculate model output\n",
    "        loss = criterion(output, label) # calculate loss\n",
    "\n",
    "        # you should also calculate some metrics, like accuracy\n",
    "        accuracy += (output.argmax(-1) == label).sum().item()\n",
    "        total_elements += output.shape[0] # we will use it to calculate accuracy\n",
    "        avg_loss += loss.item()\n",
    "\n",
    "    # batch-idx + 1 == the total number of batches == len(dataloader)\n",
    "    avg_loss = avg_loss / (batch_idx + 1)\n",
    "    accuracy = 100 * accuracy / total_elements\n",
    "    return avg_loss, accuracy\n",
    "\n",
    "\n",
    "def train(model, train_dataloader, val_dataloader, criterion, optimizer, scheduler, device, n_epochs):\n",
    "\n",
    "    train_avg_losses = []\n",
    "    val_avg_losses = []\n",
    "    val_accuracy_list = []\n",
    "    for epoch in range(n_epochs):        \n",
    "        train_avg_loss = train_one_epoch(model, train_dataloader, criterion, optimizer, scheduler, device)\n",
    "        val_avg_loss, val_accuracy = evaluate(model, val_dataloader, criterion, device)\n",
    "\n",
    "        # some logging\n",
    "                \n",
    "        # clear output so to redraw the plot\n",
    "        display.clear_output(wait=True)\n",
    "\n",
    "        train_avg_losses.append(train_avg_loss)\n",
    "        val_avg_losses.append(val_avg_loss)\n",
    "        val_accuracy_list.append(val_accuracy)\n",
    "\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n",
    "\n",
    "        axes[0].plot(train_avg_losses, color=\"blue\", label=\"train\")\n",
    "        axes[0].plot(val_avg_losses, color=\"red\", label=\"val\")\n",
    "        axes[0].set_xlabel(\"Epoch number\")\n",
    "        axes[0].set_ylabel(\"Loss\")\n",
    "        axes[0].set_title(f\"Min train loss: {round(min(train_avg_losses), 5)}, min val loss: {round(min(val_avg_losses), 5)}\")\n",
    "\n",
    "        axes[1].plot(val_accuracy_list, color=\"red\", label=\"val\")\n",
    "        axes[1].set_xlabel(\"Epoch number\")\n",
    "        axes[1].set_ylabel(\"Accuracy (%)\")\n",
    "        axes[1].set_title(f\"Best Accuracy (%): {max(val_accuracy_list)}\")\n",
    "        \n",
    "        plt.legend()\n",
    "        plt.tight_layout()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b7fd00a4-a53e-4d88-8926-feb6b6a7c445",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\" # \"cuda\" -- use GPU, \"cpu\" -- use CPU\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3504dc2a-ffc2-49d2-8525-2cb4d3ab5dde",
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_EPOCHS = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a694f717-4b7d-418f-9944-5dad0e4a0c18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FC net\n",
    "\n",
    "# do not forget to put the model itself on device\n",
    "fc_net = FCNetwork(example_img.flatten().shape[0], 128, 10) # 10 labels\n",
    "fc_net.to(device)\n",
    "\n",
    "# define optimizer and scheduler to update weights and learning rate, respectively\n",
    "optimizer = torch.optim.Adam(fc_net.parameters(), lr=3e-4)\n",
    "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=NUM_EPOCHS * len(train_dataloader), eta_min=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a20f866c-3af8-48b8-921c-bf8661f1d1be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 488,
       "width": 990
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train(fc_net, train_dataloader, val_dataloader, criterion, optimizer, scheduler, device, NUM_EPOCHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9c8734e4-373d-4255-86e6-7acd0ef2e1f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conv net\n",
    "\n",
    "# do not forget to put the model itself on device\n",
    "conv_net = ConvNetwork(1, 32, 10, image_sizes=example_img.shape[1:]) # 10 labels\n",
    "conv_net.to(device)\n",
    "\n",
    "optimizer = torch.optim.Adam(conv_net.parameters(), lr=3e-4)\n",
    "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=NUM_EPOCHS * len(train_dataloader), eta_min=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "15d0ac02-a63b-4158-ae32-e7a08fece6b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 488,
       "width": 990
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train(conv_net, train_dataloader, val_dataloader, criterion, optimizer, scheduler, device, NUM_EPOCHS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b70cfbd-dc40-4596-b538-3e45afa22b63",
   "metadata": {},
   "source": [
    "# DL Code Tips and Good Practices (R&D Coding)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7393badc-aa4c-4c1a-9aac-2c0666c443dc",
   "metadata": {},
   "source": [
    "*IPython Notebooks are great, but ...*\n",
    "\n",
    "They are not suitable for programs that require a lot of code, flexibility, and management. Besides, navigation within the notebook is complicated. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f07ae7d-fccf-46ad-aeee-08baec667a4b",
   "metadata": {},
   "source": [
    "Let's cover several problems that IPython notebooks have and then how to solve them. To do this we will look at several modifications of the following [notebook](https://github.com/markovka17/dla/tree/2024/week03/notebook_problems_examples/Example_Structured_Simple.ipynb) that implements training pipeline for CRNN model and Keyword Spotting (KWS) Task. **Remark:** this is the only notebook that is working properly within the examples, because other notebooks aim to show visual problems."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "130d05ea-6272-4512-b1db-87eafbc8d95e",
   "metadata": {},
   "source": [
    "## Problem 1: Code Structure\n",
    "\n",
    "Let's look at [this notebook](https://github.com/markovka17/dla/tree/2024/week03/notebook_problems_examples/Example_Unstructured_Unordered.ipynb). \n",
    "\n",
    "We see a lot of code, but it is hard to understand what each cell does. This is because there is just a **wall of code** and there aren't any navigation markers that say which part of the pipeline is implemented in the considered cell.\n",
    "\n",
    "Note that IPython allows you to run cells in the order of your wish. This example abuses this feature by defining training pipeline before actual models and other stuff (even imports) are defined. Besides, some parts of the pipeline are mixed: there is part of the dataset definition, then model, then another model. then another dataset. **Only the author of the notebook** knows how to run this notebook properly. **It is bad**, because your colleagues will not be able to read and understand your code.\n",
    "\n",
    "Let's fix the order and put cells that correspond to the same aspect together (all model cells are close to each other, etc). This is done in [this notebook](https://github.com/markovka17/dla/tree/2024/week03/notebook_problems_examples/Example_Unstructured_Ordered.ipynb). We know that code is ordered and we can run the notebook. But it is **hard to navigate** in it. We need to go through all cells (or use `ctrl+F`) to understand where definition of models or dataset or something else happens. \n",
    "\n",
    "To fix this, we can add markdown cells that will add some navigation markers. This is done in [this notebook](https://github.com/markovka17/dla/tree/2024/week03/notebook_problems_examples/Example_Structured.ipynb). Navigation is improved. By using Table of Contents Jupyter (Colab, etc.) feature, we can jump to the part of our interest.\n",
    "\n",
    "However, the notebook is still hard to read due to too severe surrounding visual noise, resulted from too large cells (too much code within the cell, for example in Model V3). We can try to improve this notebook even further, but this will make it more and more similar to project-style code structuring, which we will show below. Because of other IPython problems, this project-style structuring should not be done in IPython."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1b8e3cd-52b0-4db5-8ef0-5e6c3db8b066",
   "metadata": {},
   "source": [
    "## Problem 2: Configuration\n",
    "\n",
    "This problem is also related to the code structure. Imagine you want to compare two models `Model1` and `Model2` withing the same pipeline. In the example above (or in this Notebook) you will have to copy-paste definition of optimizers, schedulers, etc., because they all depend on the model. Or imagine that you want to find best hyper-parameters for your models (the best number of channels in Convolutions, the best learning rate, etc.).\n",
    "\n",
    "All of these require copy-pasting. This can be simplified using configs (like `dataclass` as was used in the KWS notebook), but it is still not beautiful and user-friendly enough.\n",
    "\n",
    "**Note**:\n",
    "\n",
    "Even if you are using configs, you may pollute your repository files with tons of similar config files:\n",
    "\n",
    "<div>\n",
    "<img src=\"pics/configs_zero.png\" width=\"200\"/>\n",
    "</div>\n",
    "\n",
    "Or pollute your Git history with _Update Config_ commits:\n",
    "\n",
    "<div>\n",
    "<img src=\"pics/configs_one.png\" width=\"100\"/>\n",
    "</div>\n",
    "\n",
    "It is okay to create new configs for your final (or important) configuration setups. But if you copy-paste files or modify original ones just to change a single line (see below), it worsens your code history and project structure:\n",
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"pics/configs_two.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "394113e8-28c9-48d4-9091-e265fbae09d3",
   "metadata": {},
   "source": [
    "## Problem 3: IPython and Git\n",
    "\n",
    "`Git` enables versioning of your code and allows you to properly work with colleagues by managing branches. If you do a new commit, your colleagues can look at the differences between new and old commits to understand what exactly was modified. If you and your teammate work on the same file, it should be possible to easily merge these 2 versions of the same file.\n",
    "\n",
    "**This does not work properly with IPython notebooks**. The problem with IPython is that even simple rerunning of code cell leads to modification that is marked as difference by `git diff`. Let's do an experiment:\n",
    "\n",
    "1. `git clone` [this repo](https://github.com/markovka17/dla/tree/2024/)\n",
    "2. Run `git status` in the cloned directory $\\Rightarrow$ you should see that no files are modified\n",
    "\n",
    "<div>\n",
    "<img src=\"pics/git_one.png\" width=\"200\"/>\n",
    "</div>\n",
    "\n",
    "3. Open the [notebook from the first week](https://github.com/markovka17/dla/blob/2024/week01/intro_to_pytorch/Seminar_1_PyTorch_Basics.ipynb) in your cloned directory. Run the first code cell, then the 3rd one, then the 2nd one.\n",
    "4. Run `git diff` in your terminal. You will see that we changed the cell execution count and this is considered as modification\n",
    "\n",
    "<div>\n",
    "<img src=\"pics/git_two.png\" width=\"200\"/>\n",
    "</div>\n",
    "\n",
    "As we discussed, by using IPython it is easy to abuse the order of cells. Also the cell can be run several times for some author's reasons. Therefore, such modifications can happen often and they litter the **actual important modifications** like actual change of code.\n",
    "\n",
    "But what if we actually change the code in the IPython notebook? The difference will look like this:\n",
    "\n",
    "<div>\n",
    "<img src=\"pics/git_three.png\" width=\"400\"/>\n",
    "</div>\n",
    "\n",
    "We can see which lines of code were added and their content. But we also see a lot of IPython stuff, like `outputs` or `metadata`. The change in outputs can look even worse and significantly litter the diff. Here is the result of changing cell output caused by `matplotlib.plt`: \n",
    "\n",
    "<div>\n",
    "<img src=\"pics/git_four.png\" width=\"400\"/>\n",
    "</div>\n",
    "\n",
    "All of these makes it difficult to merge IPython notebooks from different branches, therefore, making it **hard to work together with your teammates**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f959211-d366-4a56-9839-2a255b660b7d",
   "metadata": {},
   "source": [
    "## Problem 4: IPython and Remote programs, experiments, development, etc.\n",
    "\n",
    "Usually, you do not train models on your laptop \\ home computer due to hardware limitations, noise that does not allow you to sleep, etc. Instead, you or your company uses remote server and connect to it via `ssh`. However, you need your laptop \\ computer for other things too and you can't run `ssh` terminal 24\\7. If you close `ssh` connection, the terminal on the server will also close, crushing your program. To avoid this, people use [tmux](https://github.com/tmux/tmux), a program that creates new terminal instance, which does not close when you disconnect from your server $\\Rightarrow$ your programs will still run on the server.\n",
    "\n",
    "Using `tmux` terminal, you can open notebook on your remote server (with `Jupyter`, for example) and do all you want to. Then you can close `ssh` connection and your notebook will still be running. However, the **cell output will not update**. Try this experiment:\n",
    "\n",
    "1. Run the first sections in this notebook (which you are reading) where we train FC network\n",
    "2. Note that you see progress bar and its movement\n",
    "3. While the model still trains, close the Jupyter tab in your browser\n",
    "4. Open the notebook again\n",
    "5. Try to run the first cell\n",
    "6. Note that it is **not** running, because it is waiting for other cells to finish. This is expected, as your model is still training.\n",
    "7. But if you go to the cell with model training, you won't see any progress bar!\n",
    "\n",
    "So your notebook **will continue running cells** even if you close the Jupyter tab in the browser, but it **won't update cell output**. This makes it hard to distinguish whether your cell finished running or not (how close it is to finishing, no progress bar, etc.) and what was the output of the cell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9bc23c9-feba-4078-b8e6-8cde85b55846",
   "metadata": {},
   "source": [
    "## Solution\n",
    "\n",
    "To overcome these issues, we should write code in `.py` files instead of IPython. This will straightforwardly solve Problems 3 and 4 because git work properly with `.py` files and because we will run Python script in `tmux` instead of a Jupyter notebook. However, writing everything in a single file will make navigation hard. To avoid this, we can use Python packaging support. \n",
    "\n",
    "How does it work? We already know how to import packages like PyTorch or Numpy:\n",
    "\n",
    "```python\n",
    "from torch import nn # for example\n",
    "```\n",
    "\n",
    "We can create our own package and use its objects\\functions (they are defined in our package) in the same manner. For example, let's create the following files:\n",
    "\n",
    "```bash\n",
    ".\n",
    "├── src # directory with the core objects\\funcs\n",
    "│   ├── __init__.py # required for Python to know that src is a package\n",
    "│   └── some_funcs.py # some .py file with definition of some funcs\n",
    "└── main.py # main script to run the code\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "96e87009-9a14-46f9-8e55-dd752bc975db",
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir src # create src dir\n",
    "!touch src/__init__.py # create empty py file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b6193be-2ad3-44d9-a2d1-f79e3f65c431",
   "metadata": {},
   "source": [
    "`%%writefile` is cell magic to create files directly in IPython notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d6784871-b0b2-4f68-968f-ec6e6357fdd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/some_funcs.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/some_funcs.py\n",
    "def my_square(x): # for example, let's have this func\n",
    "    return x**2\n",
    "\n",
    "class MyNumber: # for example, let's have some class definition\n",
    "    def __init__(self, x):\n",
    "        self.x = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8009c8fc-fda8-4808-9884-b9c30d7d34be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing main.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile main.py \n",
    "\n",
    "# because src is a package now, we can use it in the same manner as we used torch\n",
    "from src.some_funcs import my_square, MyNumber\n",
    "\n",
    "# some example code\n",
    "x = 10\n",
    "mynumber = MyNumber(x)\n",
    "print(mynumber.x)\n",
    "mynumber.x = my_square(mynumber.x)\n",
    "print(mynumber.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "480886f8-be1e-4d08-b07e-ab2d7126731b",
   "metadata": {},
   "source": [
    "No we can run `main.py` and all imports will work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "74d4b73e-d5c6-4ac7-97e8-6f117a5932b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "!python3 main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10faeff2-82df-4063-8fa9-645445255bb9",
   "metadata": {},
   "source": [
    "So instead of having everything in one large file `main.py` we divided the code into several sub-files, making it easier to navigate.\n",
    "\n",
    "Note that we can import everything from our notebook if we want to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6faba575-7cd3-450a-ae9a-f7341e3210ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from src.some_funcs import my_square\n",
    "\n",
    "my_square(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c18911f1-c6a2-4400-98f3-93f69c888bbd",
   "metadata": {},
   "source": [
    "If we do not want to use long path to func\\object like `src.some_funcs`, we can write them only in `__init__.py` file. Then in `main.py`, we will be able to import from `src` directly. Let's see an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ebc61858-c14f-4a9a-a7e9-3a3e61a1efbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/__init__.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/__init__.py \n",
    "\n",
    "# we could use from ... import *\n",
    "# to import everything\n",
    "# but it would be a bad code style\n",
    "from src.some_funcs import my_square, MyNumber"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ce609ff8-6aac-49d7-a79b-ced6f9b8c8fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile main.py \n",
    "\n",
    "# because src is a package now, we can use it in the same manner as we used torch\n",
    "from src import my_square, MyNumber\n",
    "\n",
    "# some example code\n",
    "x = 10\n",
    "mynumber = MyNumber(x)\n",
    "print(mynumber.x)\n",
    "mynumber.x = my_square(mynumber.x)\n",
    "print(mynumber.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "175cee89-2e43-47f8-ac09-11cb01752ddd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "!python3 main.py # still works"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a20df8a-b5e0-48e4-9396-ad32f98d96ee",
   "metadata": {},
   "source": [
    "It is also possible to create nested packages:\n",
    "\n",
    "```bash\n",
    ".\n",
    "├── src # directory with the core objects\\funcs\n",
    "│   ├── __init__.py # required for Python to know that src is a package\n",
    "│   ├── some_funcs.py # some .py file with definition of some funcs   \n",
    "│   └── some_sub_package # directory with some other objects and funcs\n",
    "│       ├── __init__.py   # required for Python to know that some_sub_package is a package\n",
    "│       └── more_funcs.py # some .py file with the definition of some funcs\n",
    "└── main.py # main script to run the code\n",
    "```\n",
    "\n",
    "Nested packages can be used in the same manner:\n",
    "\n",
    "```python\n",
    "from src.some_sub_package import something # something should be defined in some_sub_package/__init__.py\n",
    "\n",
    "# or from src.some_sub_package.more_funcs import something if we do not import in __init__.py\n",
    "\n",
    "result = something(some_input)\n",
    "print(result)\n",
    "```\n",
    "\n",
    "Note that `main.py` is located outside of `src`. If we put it inside, we can get python error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b05efc95-e4fd-4b7c-a28f-968eb7964151",
   "metadata": {},
   "outputs": [],
   "source": [
    "!mv main.py src/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a94aa8cc-6e21-401f-9e38-54c6b660beea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    from src import my_square, MyNumber\n",
      "ModuleNotFoundError: No module named 'src'\n"
     ]
    }
   ],
   "source": [
    "# !python3 src/main.py - run this\n",
    "# 2>&1 | tail -2 is just some magic to crop the error output\n",
    "!python3 src/main.py 2>&1 | tail -2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7ac0f6d-7737-4182-b198-454863cdeea5",
   "metadata": {},
   "source": [
    "To fix this, run code in the following way instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "66e15122-981b-45a3-9c53-f97e33db6c0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "!python3 -m src.main"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f6f1204-cd43-4953-a938-d960b0f85160",
   "metadata": {},
   "source": [
    "For configuration enhancement and simplification, we can use [Hydra](https://hydra.cc/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b76bdccf-5f03-464a-b94e-6535f12674ce",
   "metadata": {},
   "source": [
    "### Deep Learning Case\n",
    "\n",
    "For deep learning projects, we can do the same thing. To simplify navigation and enhance code structure, we can create a separate sub package for each component: datasets, models, training pipeline, etc.\n",
    "\n",
    "We provide a cool [template](https://github.com/Blinorot/pytorch_project_template) where structuring is already done for you. All you have to do is to change some parts that are unique for your task: for example, add your model or change loss function. \n",
    "\n",
    "Let's look how it is structured:\n",
    "\n",
    "```bash\n",
    ".\n",
    "├── requirements.txt             # the list of packages that have to be installed (via pip or conda)\n",
    "├── src                          # main code source\n",
    "│   ├── configs                  # Hydra Configs for experiment configuration\n",
    "│   │   ├── baseline.yaml        # general config\n",
    "│   │   ├── inference.yaml       # general inference config\n",
    "│   │   ├── dataloader           # subconfig dir to simplify hydra usage and avoid copy-pasting\n",
    "│   │   ├── datasets\n",
    "│   │   ├── metrics\n",
    "│   │   ├── model\n",
    "│   │   ├── transforms\n",
    "│   │   └── writer\n",
    "│   ├── datasets                 # sub-package with all dataset-related definitions\n",
    "│   │   ├── base_dataset.py      # base class that does general pre-processing (does the same thing for several datasets)\n",
    "│   │   ├── collate.py           # collate_fn for dataloader\n",
    "│   │   ├── example.py           # nested class for base class that defines the dataset elements\n",
    "│   │   ├── data_utils.py        # init dataloaders and batch transforms\n",
    "│   │   └── __init__.py\n",
    "│   ├── __init__.py\n",
    "│   ├── logger                   # sub-package with all logging-related stuff, including wandb\n",
    "│   │   ├── __init__.py\n",
    "│   │   ├── logger_config.json\n",
    "│   │   ├── logger.py            # logger code to save logs\n",
    "│   │   ├── utils.py             # utils for logging, e.g. matplotlib figures\n",
    "│   │   ├── cometml.py           # wrapper over Comet ML\n",
    "│   │   └── wandb.py             # wrapper over W&B\n",
    "│   ├── loss                     # sub-package for loss functions\n",
    "│   │   ├── example.py\n",
    "│   │   └── __init__.py\n",
    "│   ├── metrics                  # sub-package for metrics\n",
    "│   │   ├── base_metric.py       # base class for metrics\n",
    "│   │   ├── example.py           # nested class that defines exact metric\n",
    "│   │   ├── __init__.py\n",
    "│   │   └── tracker.py           # wrapper around metrics to average metric across batches\n",
    "│   ├── model                    # sub-package for models\n",
    "│   │   ├── baseline_model.py    # definition of model\n",
    "│   │   └── __init__.py\n",
    "│   ├── trainer                  # sub-package for training\\inference pipeline\n",
    "│   │   ├── base_trainer.py      # base class for training\\infrerence and checkpointing\n",
    "│   │   ├── __init__.py\n",
    "│   │   ├── inferencer.py        # definition of inference batch processing (saving predictions, etc.)\n",
    "│   │   └── trainer.py           # definition of batch processing for our task\n",
    "│   ├── transforms               # sub-package for custom transforms and augmentations\n",
    "│   │   ├── __init__.py\n",
    "│   │   ├── normalize.py\n",
    "│   │   └── scale.py\n",
    "│   └── utils                    # sub-package for some utils\n",
    "│       ├── __init__.py\n",
    "│       ├── init_utils.py        # init loggers, checkpoint directory, writer\n",
    "│       └── io_utils.py          # extra IO utils\n",
    "├── inference.py                 # inference script (save predictions, calculate final metrics, etc.)\n",
    "└── train.py                     # main script to train the model\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "The problem with copy-pasting for running different experiments is also solved in this template via [Hydra](https://hydra.cc/). You can read more about it in [Hydra Tutorials](https://hydra.cc/docs/tutorials/intro/) and in [Python Dev Tools Repo](https://github.com/ebezzam/python-dev-tips), specifically [here](https://pydevtips.readthedocs.io/en/latest/reproducible.html#separating-configuration-from-code) and [here](https://pydevtips.readthedocs.io/en/latest/clean_code.html#avoiding-long-if-else-statements-with-object-instantiation). \n",
    "\n",
    "Note that we are using sub-directories for configs, the technique described [here](https://hydra.cc/docs/tutorials/basic/your_first_app/config_groups/). This enables easy switching between different models. **Before moving on, it is better to read the links above**.\n",
    "\n",
    "Let's see in more details:\n",
    "\n",
    "The main configs are located in `src/configs` directly. In this example, it is only `baseline.yaml`. In uses sub-configs from sub-directories and combines them into single file (to be precise, it shows Hydra how to combine them). To run the code, you should do this in your terminal:\n",
    "\n",
    "```bash\n",
    "python3 train.py -cn=CONFIG_NAME\n",
    "```\n",
    "\n",
    "Where `CONFIG_NAME` is one of the main configs from `src/configs`, for example `baseline.yaml`. Note that you should write `baseline` (i.e., config name without yaml suffix), i.e. `-cn=baseline`.\n",
    "\n",
    "Imagine you have 2 different architectures `Model1` and `Model2`. You can create separate configs for them in `src/configs/models` named `Model1.yaml` and `Model2.yaml`, respectively. Then, all you have to do to run the same pipeline with `Model1` (if it is not default model in you main config, such as`baseline.yaml`) is to change you command to:\n",
    "\n",
    "```bash\n",
    "python3 train.py -cn=CONFIG_NAME model=Model1 # note that we do not write .yaml here\n",
    "```\n",
    "\n",
    "And with `Model2`:\n",
    "```bash\n",
    "python3 train.py -cn=CONFIG_NAME model=Model2\n",
    "```\n",
    "\n",
    "The name correspond to the name of you config, it can be anything. For example, you can name your's `Model2` config as `second_model.yaml` and run the code as follows:\n",
    "\n",
    "```bash\n",
    "python3 train.py -cn=CONFIG_NAME model=second_model\n",
    "```\n",
    "\n",
    "Also it is possible to change hyperparameters together with sub-configs. For example, your `Model2` can have hyperparameter named `hidden_size`. There is its default value in `second_model.yaml`, but we can change it in command-line:\n",
    "\n",
    "```bash\n",
    "python3 train.py -cn=CONFIG_NAME model=second_model model.hidden_size=new_value_for_hidden_size\n",
    "```\n",
    "\n",
    "This way, you **do not need to change code or copy-paste stuff (both code and configs)** to run different experiments with different setups. This makes code and experiments much clearer and simpler. All of these is possible because of Hydra ability to concatenate configs and its `instantiate` method that directly creates objects, given their config and `_target_` class.\n",
    "\n",
    "Another trick here is that you can set several config arguments to the same value using `${}` instead of explicitly writing an argument value. And this works even between sub-directories (**Remark**: you should be careful with the `defaults` in the main config to make it work between sub-directories). For example, `src/configs/datasets/example.yaml` does not explicitly write `instance_transforms` variable. Instead, the `instance_transforms` are defined in their own sub-directory and `datasets` just use `${transforms.instance_transforms.train}`. Hydra will see the definition of `${transforms.instance_transforms.train}` in `instance_transforms` sub-directory and then use this definition inside `datasets` config."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df2c5e62-b74a-4b45-a74a-66ec6580712c",
   "metadata": {},
   "source": [
    "## Remark\n",
    "\n",
    "It should be mentioned that ability to run parts of the code is a plus for IPython notebooks. For example, we can look at the sample from the dataset and see how does it look.\n",
    "\n",
    "```python\n",
    "# Example from KWS notebook\n",
    "dataset.index[:2]\n",
    "\n",
    "# Example from this seminar\n",
    "example_img, example_label = mnist_train[0]\n",
    "print(example_img.shape) # C x H x W, 1 channel -- grayscale image\n",
    "plt.imshow(example_img[0])\n",
    "plt.title(example_label)\n",
    "plt.show()\n",
    "```\n",
    "\n",
    "However, most of this can be done using project-style structure too. Just create an empty notebook (which is used **only** for validating your code by visualizing some stuff) and do:\n",
    "\n",
    "```python\n",
    "# alternative to KWS notebook\n",
    "from src.datasets import SpeechCommandDataset\n",
    "\n",
    "dataset = SpeechCommandDataset(\n",
    "    path2dir='speech_commands', keywords=TaskConfig.keyword\n",
    ")\n",
    "\n",
    "dataset.index[:2]\n",
    "```\n",
    "\n",
    "We preserve visualizing capabilities but simplify notebook by moving all complicated code (like the dataset class) to a separate file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05f9158d-4ee4-4c7a-ad3a-4edddfcee8f7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}