Chapter02.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Learning with PyTorch Step-by-Step: A Beginner's Guide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 2.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB The following cell is only needed for Google Colab."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "try:\n",
    "    import google.colab\n",
    "    import requests\n",
    "    url = 'https://raw.githubusercontent.com/dvgodoy/PyTorchStepByStep/master/config.py'\n",
    "    r = requests.get(url, allow_redirects=True)\n",
    "    open('config.py', 'wb').write(r.content)    \n",
    "except ModuleNotFoundError:\n",
    "    pass\n",
    "\n",
    "from config import *\n",
    "config_chapter2_1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is needed to render the plots in this chapter\n",
    "from plots.chapter2_1 import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import datetime\n",
    "\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torch.functional as F\n",
    "from torch.utils.data import DataLoader, TensorDataset, random_split\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.style.use('fivethirtyeight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Going Classy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A completely empty (and useless) class\n",
    "class StepByStep(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Constructor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StepByStep(object):\n",
    "    def __init__(self, model, loss_fn, optimizer):\n",
    "        # Here we define the attributes of our class\n",
    "        \n",
    "        # We start by storing the arguments as attributes \n",
    "        # to use them later\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "        # NB\n",
    "        self.device = 'mps' if torch.has_mps else self.device\n",
    "        # Let's send the model to the specified device right away\n",
    "        self.model.to(self.device)\n",
    "        \n",
    "    def to(self, device):\n",
    "        # This method allows the user to specify a different device\n",
    "        # It sets the corresponding attribute (to be used later in\n",
    "        # the mini-batches) and sends the model to the device\n",
    "        try:\n",
    "            self.device = device\n",
    "            self.model.to(self.device)\n",
    "        except RuntimeError:\n",
    "            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "            # NB\n",
    "            self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "            print(f\"Couldn't send it to {device}, sending it to {self.device} instead.\")\n",
    "            self.model.to(self.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Placeholders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StepByStep(object):\n",
    "    def __init__(self, model, loss_fn, optimizer):\n",
    "        # Here we define the attributes of our class\n",
    "        \n",
    "        # We start by storing the arguments as attributes \n",
    "        # to use them later\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "        # NB\n",
    "        self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "        # Let's send the model to the specified device right away\n",
    "        self.model.to(self.device)\n",
    "        \n",
    "        # These attributes are defined here, but since they are\n",
    "        # not available at the moment of creation, we keep them None\n",
    "        self.train_loader = None\n",
    "        self.val_loader = None\n",
    "        self.writer = None\n",
    "\n",
    "    def to(self, device):\n",
    "        # This method allows the user to specify a different device\n",
    "        # It sets the corresponding attribute (to be used later in\n",
    "        # the mini-batches) and sends the model to the device\n",
    "        try:\n",
    "            self.device = device\n",
    "            self.model.to(self.device)\n",
    "        except RuntimeError:\n",
    "            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "            # NB\n",
    "            self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "            print(f\"Couldn't send it to {device}, sending it to {self.device} instead.\")\n",
    "            self.model.to(self.device)\n",
    "\n",
    "    def set_loaders(self, train_loader, val_loader=None):\n",
    "        # This method allows the user to define which train_loader \n",
    "        # (and val_loader, optionally) to use\n",
    "        # Both loaders are then assigned to attributes of the class\n",
    "        # So they can be referred to later\n",
    "        self.train_loader = train_loader\n",
    "        self.val_loader = val_loader\n",
    "\n",
    "    def set_tensorboard(self, name, folder='runs'):\n",
    "        # This method allows the user to create a SummaryWriter to \n",
    "        # interface with TensorBoard\n",
    "        suffix = datetime.datetime.now().strftime('%Y%m%d%H%M%S')\n",
    "        self.writer = SummaryWriter(f'{folder}/{name}_{suffix}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StepByStep(object):\n",
    "    def __init__(self, model, loss_fn, optimizer):\n",
    "        # Here we define the attributes of our class\n",
    "        \n",
    "        # We start by storing the arguments as attributes \n",
    "        # to use them later\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "        # NB\n",
    "        self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "        # Let's send the model to the specified device right away\n",
    "        self.model.to(self.device)\n",
    "        \n",
    "        # These attributes are defined here, but since they are\n",
    "        # not available at the moment of creation, we keep them None\n",
    "        self.train_loader = None\n",
    "        self.val_loader = None\n",
    "        self.writer = None\n",
    "\n",
    "        # These attributes are going to be computed internally\n",
    "        self.losses = []\n",
    "        self.val_losses = []\n",
    "        self.total_epochs = 0\n",
    "\n",
    "    def to(self, device):\n",
    "        # This method allows the user to specify a different device\n",
    "        # It sets the corresponding attribute (to be used later in\n",
    "        # the mini-batches) and sends the model to the device\n",
    "        try:\n",
    "            self.device = device\n",
    "            self.model.to(self.device)\n",
    "        except RuntimeError:\n",
    "            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "            # NB\n",
    "            self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "            print(f\"Couldn't send it to {device}, sending it to {self.device} instead.\")\n",
    "            self.model.to(self.device)\n",
    "\n",
    "    def set_loaders(self, train_loader, val_loader=None):\n",
    "        # This method allows the user to define which train_loader \n",
    "        # (and val_loader, optionally) to use\n",
    "        # Both loaders are then assigned to attributes of the class\n",
    "        # So they can be referred to later\n",
    "        self.train_loader = train_loader\n",
    "        self.val_loader = val_loader\n",
    "\n",
    "    def set_tensorboard(self, name, folder='runs'):\n",
    "        # This method allows the user to create a SummaryWriter to \n",
    "        # interface with TensorBoard\n",
    "        suffix = datetime.datetime.now().strftime('%Y%m%d%H%M%S')\n",
    "        self.writer = SummaryWriter(f'{folder}/{name}_{suffix}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StepByStep(object):\n",
    "    def __init__(self, model, loss_fn, optimizer):\n",
    "        # Here we define the attributes of our class\n",
    "        \n",
    "        # We start by storing the arguments as attributes \n",
    "        # to use them later\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "        # NB\n",
    "        self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "        # Let's send the model to the specified device right away\n",
    "        self.model.to(self.device)\n",
    "        \n",
    "        # These attributes are defined here, but since they are\n",
    "        # not available at the moment of creation, we keep them None\n",
    "        self.train_loader = None\n",
    "        self.val_loader = None\n",
    "        self.writer = None\n",
    "\n",
    "        # These attributes are going to be computed internally\n",
    "        self.losses = []\n",
    "        self.val_losses = []\n",
    "        self.total_epochs = 0\n",
    "\n",
    "        # Creates the train_step function for our model, \n",
    "        # loss function and optimizer\n",
    "        # Note: there are NO ARGS there! It makes use of the class\n",
    "        # attributes directly\n",
    "        self.train_step = self._make_train_step()\n",
    "        # Creates the val_step function for our model and loss\n",
    "        self.val_step = self._make_val_step()\n",
    "\n",
    "    def to(self, device):\n",
    "        # This method allows the user to specify a different device\n",
    "        # It sets the corresponding attribute (to be used later in\n",
    "        # the mini-batches) and sends the model to the device\n",
    "        try:\n",
    "            self.device = device\n",
    "            self.model.to(self.device)\n",
    "        except RuntimeError:\n",
    "            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "            # NB\n",
    "            self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "            print(f\"Couldn't send it to {device}, sending it to {self.device} instead.\")\n",
    "            self.model.to(self.device)\n",
    "\n",
    "    def set_loaders(self, train_loader, val_loader=None):\n",
    "        # This method allows the user to define which train_loader \n",
    "        # (and val_loader, optionally) to use\n",
    "        # Both loaders are then assigned to attributes of the class\n",
    "        # So they can be referred to later\n",
    "        self.train_loader = train_loader\n",
    "        self.val_loader = val_loader\n",
    "\n",
    "    def set_tensorboard(self, name, folder='runs'):\n",
    "        # This method allows the user to create a SummaryWriter to \n",
    "        # interface with TensorBoard\n",
    "        suffix = datetime.datetime.now().strftime('%Y%m%d%H%M%S')\n",
    "        self.writer = SummaryWriter(f'{folder}/{name}_{suffix}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _make_train_step_fn(self):\n",
    "    # This method does not need ARGS... it can refer to\n",
    "    # the attributes: self.model, self.loss_fn and self.optimizer\n",
    "\n",
    "    # Builds function that performs a step in the train loop\n",
    "    def perform_train_step_fn(x, y):\n",
    "        # Sets model to TRAIN mode\n",
    "        self.model.train()\n",
    "\n",
    "        # Step 1 - Computes our model's predicted output - forward pass\n",
    "        yhat = self.model(x)\n",
    "        # Step 2 - Computes the loss\n",
    "        loss = self.loss_fn(yhat, y)\n",
    "        # Step 3 - Computes gradients for both \"b\" and \"w\" parameters\n",
    "        loss.backward()\n",
    "        # Step 4 - Updates parameters using gradients and the\n",
    "        # learning rate\n",
    "        self.optimizer.step()\n",
    "        self.optimizer.zero_grad()\n",
    "\n",
    "        # Returns the loss\n",
    "        return loss.item()\n",
    "\n",
    "    # Returns the function that will be called inside the train loop\n",
    "    return perform_train_step_fn\n",
    "\n",
    "def _make_val_step_fn(self):\n",
    "    # Builds function that performs a step in the validation loop\n",
    "    def perform_val_step_fn(x, y):\n",
    "        # Sets model to EVAL mode\n",
    "        self.model.eval()\n",
    "\n",
    "        # Step 1 - Computes our model's predicted output - forward pass\n",
    "        yhat = self.model(x)\n",
    "        # Step 2 - Computes the loss\n",
    "        loss = self.loss_fn(yhat, y)\n",
    "        # There is no need to compute Steps 3 and 4, \n",
    "        # since we don't update parameters during evaluation\n",
    "        return loss.item()\n",
    "\n",
    "    return perform_val_step_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ATTENTION! Using SETATTR for educational purposes only :-)\n",
    "setattr(StepByStep, '_make_train_step_fn', _make_train_step_fn)\n",
    "setattr(StepByStep, '_make_val_step_fn', _make_val_step_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### setattr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rex\n"
     ]
    }
   ],
   "source": [
    "rex = Dog('Rex')\n",
    "print(rex.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bark(dog):\n",
    "    print('{} barks: \"Woof!\"'.format(dog.name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rex barks: \"Woof!\"\n"
     ]
    }
   ],
   "source": [
    "bark(rex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bark(self):\n",
    "    print('{} barks: \"Woof!\"'.format(self.name))\n",
    "\n",
    "setattr(Dog, 'bark', bark)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fido barks: \"Woof!\"\n"
     ]
    }
   ],
   "source": [
    "fido = Dog('Fido')\n",
    "fido.bark()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rex barks: \"Woof!\"\n"
     ]
    }
   ],
   "source": [
    "rex.bark()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mini-Batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _mini_batch(self, validation=False):\n",
    "    # The mini-batch can be used with both loaders\n",
    "    # The argument `validation`defines which loader and \n",
    "    # corresponding step function is going to be used\n",
    "    if validation:\n",
    "        data_loader = self.val_loader\n",
    "        step_fn = self.val_step_fn\n",
    "    else:\n",
    "        data_loader = self.train_loader\n",
    "        step_fn = self.train_step_fn\n",
    "\n",
    "    if data_loader is None:\n",
    "        return None\n",
    "\n",
    "    # Once the data loader and step function, this is the same\n",
    "    # mini-batch loop we had before\n",
    "    mini_batch_losses = []\n",
    "    for x_batch, y_batch in data_loader:\n",
    "        x_batch = x_batch.to(self.device)\n",
    "        y_batch = y_batch.to(self.device)\n",
    "\n",
    "        mini_batch_loss = step_fn(x_batch, y_batch)\n",
    "        mini_batch_losses.append(mini_batch_loss)\n",
    "\n",
    "    loss = np.mean(mini_batch_losses)\n",
    "\n",
    "    return loss\n",
    "\n",
    "setattr(StepByStep, '_mini_batch', _mini_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_seed(self, seed=42):\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False    \n",
    "    torch.manual_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "setattr(StepByStep, 'set_seed', set_seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(self, n_epochs, seed=42):\n",
    "    # To ensure reproducibility of the training process\n",
    "    self.set_seed(seed)\n",
    "    \n",
    "    for epoch in range(n_epochs):\n",
    "        # Keeps track of the numbers of epochs\n",
    "        # by updating the corresponding attribute\n",
    "        self.total_epochs += 1\n",
    "\n",
    "        # inner loop\n",
    "        # Performs training using mini-batches\n",
    "        loss = self._mini_batch(validation=False)\n",
    "        self.losses.append(loss)\n",
    "\n",
    "        # VALIDATION\n",
    "        # no gradients in validation!\n",
    "        with torch.no_grad():\n",
    "            # Performs evaluation using mini-batches\n",
    "            val_loss = self._mini_batch(validation=True)\n",
    "            self.val_losses.append(val_loss)\n",
    "\n",
    "        # If a SummaryWriter has been set...\n",
    "        if self.writer:\n",
    "            scalars = {'training': loss}\n",
    "            if val_loss is not None:\n",
    "                scalars.update({'validation': val_loss})\n",
    "            # Records both losses for each epoch under the main tag \"loss\"\n",
    "            self.writer.add_scalars(main_tag='loss',\n",
    "                                    tag_scalar_dict=scalars,\n",
    "                                    global_step=epoch)\n",
    "\n",
    "    if self.writer:\n",
    "        # Flushes the writer\n",
    "        self.writer.flush()\n",
    "        \n",
    "setattr(StepByStep, 'train', train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving and Loading Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_checkpoint(self, filename):\n",
    "    # Builds dictionary with all elements for resuming training\n",
    "    checkpoint = {'epoch': self.total_epochs,\n",
    "                  'model_state_dict': self.model.state_dict(),\n",
    "                  'optimizer_state_dict': self.optimizer.state_dict(),\n",
    "                  'loss': self.losses,\n",
    "                  'val_loss': self.val_losses}\n",
    "\n",
    "    torch.save(checkpoint, filename)\n",
    "    \n",
    "setattr(StepByStep, 'save_checkpoint', save_checkpoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_checkpoint(self, filename):\n",
    "    # Loads dictionary\n",
    "    checkpoint = torch.load(filename)\n",
    "\n",
    "    # Restore state for model and optimizer\n",
    "    self.model.load_state_dict(checkpoint['model_state_dict'])\n",
    "    self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "\n",
    "    self.total_epochs = checkpoint['epoch']\n",
    "    self.losses = checkpoint['loss']\n",
    "    self.val_losses = checkpoint['val_loss']\n",
    "\n",
    "    self.model.train() # always use TRAIN for resuming training   \n",
    "    \n",
    "setattr(StepByStep, 'load_checkpoint', load_checkpoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(self, x):\n",
    "    # Set is to evaluation mode for predictions\n",
    "    self.model.eval() \n",
    "    # Takes aNumpy input and make it a float tensor\n",
    "    x_tensor = torch.as_tensor(x).float()\n",
    "    # Send input to device and uses model for prediction\n",
    "    y_hat_tensor = self.model(x_tensor.to(self.device))\n",
    "    # Set it back to train mode\n",
    "    self.model.train()\n",
    "    # Detaches it, brings it to CPU and back to Numpy\n",
    "    return y_hat_tensor.detach().cpu().numpy()\n",
    "\n",
    "setattr(StepByStep, 'predict', predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_losses(self):\n",
    "    fig = plt.figure(figsize=(10, 4))\n",
    "    plt.plot(self.losses, label='Training Loss', c='b')\n",
    "    if self.val_loader:\n",
    "        plt.plot(self.val_losses, label='Validation Loss', c='r')\n",
    "    plt.yscale('log')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.legend()\n",
    "    plt.tight_layout()\n",
    "    return fig\n",
    "\n",
    "setattr(StepByStep, 'plot_losses', plot_losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_graph(self):\n",
    "    if self.train_loader and self.writer:\n",
    "        # Fetches a single mini-batch so we can use add_graph\n",
    "        x_sample, y_sample = next(iter(self.train_loader))\n",
    "        self.writer.add_graph(self.model, x_sample.to(self.device))\n",
    "    \n",
    "setattr(StepByStep, 'add_graph', add_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Full Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load stepbystep/v0.py\n",
    "\n",
    "import numpy as np\n",
    "import datetime\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "plt.style.use('fivethirtyeight')\n",
    "\n",
    "class StepByStep(object):\n",
    "    def __init__(self, model, loss_fn, optimizer):\n",
    "        # Here we define the attributes of our class\n",
    "        \n",
    "        # We start by storing the arguments as attributes \n",
    "        # to use them later\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "        # NB\n",
    "        self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "        # Let's send the model to the specified device right away\n",
    "        self.model.to(self.device)\n",
    "\n",
    "        # These attributes are defined here, but since they are\n",
    "        # not informed at the moment of creation, we keep them None\n",
    "        self.train_loader = None\n",
    "        self.val_loader = None\n",
    "        self.writer = None\n",
    "        \n",
    "        # These attributes are going to be computed internally\n",
    "        self.losses = []\n",
    "        self.val_losses = []\n",
    "        self.total_epochs = 0\n",
    "\n",
    "        # Creates the train_step function for our model, \n",
    "        # loss function and optimizer\n",
    "        # Note: there are NO ARGS there! It makes use of the class\n",
    "        # attributes directly\n",
    "        self.train_step_fn = self._make_train_step_fn()\n",
    "        # Creates the val_step function for our model and loss\n",
    "        self.val_step_fn = self._make_val_step_fn()\n",
    "\n",
    "    def to(self, device):\n",
    "        # This method allows the user to specify a different device\n",
    "        # It sets the corresponding attribute (to be used later in\n",
    "        # the mini-batches) and sends the model to the device\n",
    "        try:\n",
    "            self.device = device\n",
    "            self.model.to(self.device)\n",
    "        except RuntimeError:\n",
    "            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "            # NB\n",
    "            self.device = 'mps' if torch.has_mps else self.device\n",
    "\n",
    "            print(f\"Couldn't send it to {device}, sending it to {self.device} instead.\")\n",
    "            self.model.to(self.device)\n",
    "\n",
    "    def set_loaders(self, train_loader, val_loader=None):\n",
    "        # This method allows the user to define which train_loader (and val_loader, optionally) to use\n",
    "        # Both loaders are then assigned to attributes of the class\n",
    "        # So they can be referred to later\n",
    "        self.train_loader = train_loader\n",
    "        self.val_loader = val_loader\n",
    "\n",
    "    def set_tensorboard(self, name, folder='runs'):\n",
    "        # This method allows the user to define a SummaryWriter to interface with TensorBoard\n",
    "        suffix = datetime.datetime.now().strftime('%Y%m%d%H%M%S')\n",
    "        self.writer = SummaryWriter(f'{folder}/{name}_{suffix}')\n",
    "\n",
    "    def _make_train_step_fn(self):\n",
    "        # This method does not need ARGS... it can refer to\n",
    "        # the attributes: self.model, self.loss_fn and self.optimizer\n",
    "        \n",
    "        # Builds function that performs a step in the train loop\n",
    "        def perform_train_step_fn(x, y):\n",
    "            # Sets model to TRAIN mode\n",
    "            self.model.train()\n",
    "\n",
    "            # Step 1 - Computes our model's predicted output - forward pass\n",
    "            yhat = self.model(x)\n",
    "            # Step 2 - Computes the loss\n",
    "            loss = self.loss_fn(yhat, y)\n",
    "            # Step 3 - Computes gradients for both \"a\" and \"b\" parameters\n",
    "            loss.backward()\n",
    "            # Step 4 - Updates parameters using gradients and the learning rate\n",
    "            self.optimizer.step()\n",
    "            self.optimizer.zero_grad()\n",
    "\n",
    "            # Returns the loss\n",
    "            return loss.item()\n",
    "\n",
    "        # Returns the function that will be called inside the train loop\n",
    "        return perform_train_step_fn\n",
    "    \n",
    "    def _make_val_step_fn(self):\n",
    "        # Builds function that performs a step in the validation loop\n",
    "        def perform_val_step_fn(x, y):\n",
    "            # Sets model to EVAL mode\n",
    "            self.model.eval()\n",
    "\n",
    "            # Step 1 - Computes our model's predicted output - forward pass\n",
    "            yhat = self.model(x)\n",
    "            # Step 2 - Computes the loss\n",
    "            loss = self.loss_fn(yhat, y)\n",
    "            # There is no need to compute Steps 3 and 4, \n",
    "            # since we don't update parameters during evaluation\n",
    "            return loss.item()\n",
    "\n",
    "        return perform_val_step_fn\n",
    "            \n",
    "    def _mini_batch(self, validation=False):\n",
    "        # The mini-batch can be used with both loaders\n",
    "        # The argument `validation`defines which loader and \n",
    "        # corresponding step function is going to be used\n",
    "        if validation:\n",
    "            data_loader = self.val_loader\n",
    "            step_fn = self.val_step_fn\n",
    "        else:\n",
    "            data_loader = self.train_loader\n",
    "            step_fn = self.train_step_fn\n",
    "\n",
    "        if data_loader is None:\n",
    "            return None\n",
    "            \n",
    "        # Once the data loader and step function, this is the \n",
    "        # same mini-batch loop we had before\n",
    "        mini_batch_losses = []\n",
    "        for x_batch, y_batch in data_loader:\n",
    "            x_batch = x_batch.to(self.device)\n",
    "            y_batch = y_batch.to(self.device)\n",
    "\n",
    "            mini_batch_loss = step_fn(x_batch, y_batch)\n",
    "            mini_batch_losses.append(mini_batch_loss)\n",
    "\n",
    "        loss = np.mean(mini_batch_losses)\n",
    "        return loss\n",
    "\n",
    "    def set_seed(self, seed=42):\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "        torch.backends.cudnn.benchmark = False    \n",
    "        torch.manual_seed(seed)\n",
    "        np.random.seed(seed)\n",
    "    \n",
    "    def train(self, n_epochs, seed=42):\n",
    "        # To ensure reproducibility of the training process\n",
    "        self.set_seed(seed)\n",
    "\n",
    "        for epoch in range(n_epochs):\n",
    "            # Keeps track of the numbers of epochs\n",
    "            # by updating the corresponding attribute\n",
    "            self.total_epochs += 1\n",
    "\n",
    "            # inner loop\n",
    "            # Performs training using mini-batches\n",
    "            loss = self._mini_batch(validation=False)\n",
    "            self.losses.append(loss)\n",
    "\n",
    "            # VALIDATION\n",
    "            # no gradients in validation!\n",
    "            with torch.no_grad():\n",
    "                # Performs evaluation using mini-batches\n",
    "                val_loss = self._mini_batch(validation=True)\n",
    "                self.val_losses.append(val_loss)\n",
    "\n",
    "            # If a SummaryWriter has been set...\n",
    "            if self.writer:\n",
    "                scalars = {'training': loss}\n",
    "                if val_loss is not None:\n",
    "                    scalars.update({'validation': val_loss})\n",
    "                # Records both losses for each epoch under the main tag \"loss\"\n",
    "                self.writer.add_scalars(main_tag='loss',\n",
    "                                        tag_scalar_dict=scalars,\n",
    "                                        global_step=epoch)\n",
    "\n",
    "        if self.writer:\n",
    "            # Closes the writer\n",
    "            self.writer.close()\n",
    "\n",
    "    def save_checkpoint(self, filename):\n",
    "        # Builds dictionary with all elements for resuming training\n",
    "        checkpoint = {'epoch': self.total_epochs,\n",
    "                      'model_state_dict': self.model.state_dict(),\n",
    "                      'optimizer_state_dict': self.optimizer.state_dict(),\n",
    "                      'loss': self.losses,\n",
    "                      'val_loss': self.val_losses}\n",
    "\n",
    "        torch.save(checkpoint, filename)\n",
    "\n",
    "    def load_checkpoint(self, filename):\n",
    "        # Loads dictionary\n",
    "        checkpoint = torch.load(filename)\n",
    "\n",
    "        # Restore state for model and optimizer\n",
    "        self.model.load_state_dict(checkpoint['model_state_dict'])\n",
    "        self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "\n",
    "        self.total_epochs = checkpoint['epoch']\n",
    "        self.losses = checkpoint['loss']\n",
    "        self.val_losses = checkpoint['val_loss']\n",
    "\n",
    "        self.model.train() # always use TRAIN for resuming training   \n",
    "\n",
    "    def predict(self, x):\n",
    "        # Set is to evaluation mode for predictions\n",
    "        self.model.eval() \n",
    "        # Takes aNumpy input and make it a float tensor\n",
    "        x_tensor = torch.as_tensor(x).float()\n",
    "        # Send input to device and uses model for prediction\n",
    "        y_hat_tensor = self.model(x_tensor.to(self.device))\n",
    "        # Set it back to train mode\n",
    "        self.model.train()\n",
    "        # Detaches it, brings it to CPU and back to Numpy\n",
    "        return y_hat_tensor.detach().cpu().numpy()\n",
    "\n",
    "    def plot_losses(self):\n",
    "        fig = plt.figure(figsize=(10, 4))\n",
    "        plt.plot(self.losses, label='Training Loss', c='b')\n",
    "        plt.plot(self.val_losses, label='Validation Loss', c='r')\n",
    "        plt.yscale('log')\n",
    "        plt.xlabel('Epochs')\n",
    "        plt.ylabel('Loss')\n",
    "        plt.legend()\n",
    "        plt.tight_layout()\n",
    "        return fig\n",
    "\n",
    "    def add_graph(self):\n",
    "        # Fetches a single mini-batch so we can use add_graph\n",
    "        if self.train_loader and self.writer:\n",
    "            x_sample, y_sample = next(iter(self.train_loader))\n",
    "            self.writer.add_graph(self.model, x_sample.to(self.device))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classy Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Runs data generation - so we do not need to copy code here\n",
    "%run -i data_generation/simple_linear_regression.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = figure1(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preparation V2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load data_preparation/v2.py\n",
    "\n",
    "torch.manual_seed(13)\n",
    "\n",
    "# Builds tensors from numpy arrays BEFORE split\n",
    "x_tensor = torch.as_tensor(x).float()\n",
    "y_tensor = torch.as_tensor(y).float()\n",
    "\n",
    "# Builds dataset containing ALL data points\n",
    "dataset = TensorDataset(x_tensor, y_tensor)\n",
    "\n",
    "# Performs the split\n",
    "ratio = .8\n",
    "n_total = len(dataset)\n",
    "n_train = int(n_total * ratio)\n",
    "n_val = n_total - n_train\n",
    "\n",
    "train_data, val_data = random_split(dataset, [n_train, n_val])\n",
    "\n",
    "# Builds a loader of each set\n",
    "train_loader = DataLoader(dataset=train_data, batch_size=16, shuffle=True)\n",
    "val_loader = DataLoader(dataset=val_data, batch_size=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Configuration V4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting model_configuration/v4.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile model_configuration/v4.py\n",
    "\n",
    "# Sets learning rate - this is \"eta\" ~ the \"n\" like Greek letter\n",
    "lr = 0.1\n",
    "\n",
    "torch.manual_seed(42)\n",
    "# Now we can create a model and send it at once to the device\n",
    "model = nn.Sequential(nn.Linear(1, 1))\n",
    "\n",
    "# Defines a SGD optimizer to update the parameters\n",
    "# (now retrieved directly from the model)\n",
    "optimizer = optim.SGD(model.parameters(), lr=lr)\n",
    "\n",
    "# Defines a MSE loss function\n",
    "loss_fn = nn.MSELoss(reduction='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%run -i model_configuration/v4.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[0.7645]])), ('0.bias', tensor([0.8300]))])\n"
     ]
    }
   ],
   "source": [
    "print(model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell 2.1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs = StepByStep(model, loss_fn, optimizer)\n",
    "sbs.set_loaders(train_loader, val_loader)\n",
    "sbs.set_tensorboard('classy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Sequential(\n",
      "  (0): Linear(in_features=1, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(sbs.model == model)\n",
    "print(sbs.model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell 2.1.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs.train(n_epochs=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[1.9416]], device='mps:0')), ('0.bias', tensor([1.0235], device='mps:0'))])\n",
      "200\n"
     ]
    }
   ],
   "source": [
    "print(model.state_dict()) # remember, model == sbs.model\n",
    "print(sbs.total_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = sbs.plot_losses()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5],\n",
       "       [0.3],\n",
       "       [0.7]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_data = np.array([.5, .3, .7]).reshape(-1, 1)\n",
    "new_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.9942763],\n",
       "       [1.605955 ],\n",
       "       [2.3825974]], dtype=float32)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions = sbs.predict(new_data)\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checkpointing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell 2.1.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs.save_checkpoint('model_checkpoint.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resuming Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%run -i model_configuration/v4.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[0.7645]])), ('0.bias', tensor([0.8300]))])\n"
     ]
    }
   ],
   "source": [
    "print(model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell 2.1.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_sbs = StepByStep(model, loss_fn, optimizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell 2.1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[1.9416]], device='mps:0')), ('0.bias', tensor([1.0235], device='mps:0'))])\n"
     ]
    }
   ],
   "source": [
    "new_sbs.load_checkpoint('model_checkpoint.pth')\n",
    "print(model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell 2.1.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_sbs.set_loaders(train_loader, val_loader)\n",
    "new_sbs.train(n_epochs=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = new_sbs.plot_losses()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[1.9416]], device='mps:0')), ('0.bias', tensor([1.0235], device='mps:0'))])\n"
     ]
    }
   ],
   "source": [
    "print(sbs.model.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Putting It All Together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load data_preparation/v2.py\n",
    "\n",
    "torch.manual_seed(13)\n",
    "\n",
    "# Builds tensors from numpy arrays BEFORE split\n",
    "x_tensor = torch.as_tensor(x).float()\n",
    "y_tensor = torch.as_tensor(y).float()\n",
    "\n",
    "# Builds dataset containing ALL data points\n",
    "dataset = TensorDataset(x_tensor, y_tensor)\n",
    "\n",
    "# Performs the split\n",
    "ratio = .8\n",
    "n_total = len(dataset)\n",
    "n_train = int(n_total * ratio)\n",
    "n_val = n_total - n_train\n",
    "\n",
    "train_data, val_data = random_split(dataset, [n_train, n_val])\n",
    "\n",
    "# Builds a loader of each set\n",
    "train_loader = DataLoader(\n",
    "    dataset=train_data,\n",
    "    batch_size=16,\n",
    "    shuffle=True\n",
    ")\n",
    "val_loader = DataLoader(dataset=val_data, batch_size=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load model_configuration/v4.py\n",
    "\n",
    "# Sets learning rate - this is \"eta\" ~ the \"n\" like Greek letter\n",
    "lr = 0.1\n",
    "\n",
    "torch.manual_seed(42)\n",
    "# Now we can create a model\n",
    "model = nn.Sequential(nn.Linear(1, 1))\n",
    "\n",
    "# Defines a SGD optimizer to update the parameters \n",
    "# (now retrieved directly from the model)\n",
    "optimizer = optim.SGD(model.parameters(), lr=lr)\n",
    "\n",
    "# Defines a MSE loss function\n",
    "loss_fn = nn.MSELoss(reduction='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_epochs = 200\n",
    "\n",
    "sbs = StepByStep(model, loss_fn, optimizer)\n",
    "sbs.set_loaders(train_loader, val_loader)\n",
    "sbs.set_tensorboard('classy')\n",
    "sbs.train(n_epochs=n_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('0.weight', tensor([[1.9416]], device='mps:0')), ('0.bias', tensor([1.0235], device='mps:0'))])\n"
     ]
    }
   ],
   "source": [
    "print(model.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}