diff --git a/Contributor_demos/Chest X-Ray Images (Pneumonia) Detection/Chest_X_Ray_Pneumonia_Detection.ipynb b/Contributor_demos/Chest X-Ray Images (Pneumonia) Detection/Chest_X_Ray_Pneumonia_Detection.ipynb
new file mode 100644
index 00000000..95daa8cd
--- /dev/null
+++ b/Contributor_demos/Chest X-Ray Images (Pneumonia) Detection/Chest_X_Ray_Pneumonia_Detection.ipynb	
@@ -0,0 +1,4206 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "eD8IKvaWr_Kh"
+      },
+      "source": [
+        "# Chest X-Ray Images (Pneumonia) Detection"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NZs7tZ1yr_Kl",
+        "outputId": "a1b7ebf5-c08e-4961-a5f2-9ba790f5bfec"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting ivy\n",
+            "  Downloading ivy-0.0.9.0-cp310-cp310-manylinux_2_17_x86_64.whl (16.4 MB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.4/16.4 MB\u001b[0m \u001b[31m14.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from ivy) (1.25.2)\n",
+            "Collecting einops (from ivy)\n",
+            "  Downloading einops-0.7.0-py3-none-any.whl (44 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.6/44.6 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from ivy) (5.9.5)\n",
+            "Requirement already satisfied: termcolor in /usr/local/lib/python3.10/dist-packages (from ivy) (2.4.0)\n",
+            "Collecting colorama (from ivy)\n",
+            "  Downloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)\n",
+            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from ivy) (24.0)\n",
+            "Collecting nvidia-ml-py (from ivy)\n",
+            "  Downloading nvidia_ml_py-12.535.133-py3-none-any.whl (37 kB)\n",
+            "Collecting diskcache (from ivy)\n",
+            "  Downloading diskcache-5.6.3-py3-none-any.whl (45 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m45.5/45.5 kB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: google-auth in /usr/local/lib/python3.10/dist-packages (from ivy) (2.27.0)\n",
+            "Collecting urllib3<2.0 (from ivy)\n",
+            "  Downloading urllib3-1.26.18-py2.py3-none-any.whl (143 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m143.8/143.8 kB\u001b[0m \u001b[31m15.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from ivy) (2.31.0)\n",
+            "Collecting pyvis (from ivy)\n",
+            "  Downloading pyvis-0.3.2-py3-none-any.whl (756 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m756.0/756.0 kB\u001b[0m \u001b[31m44.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hCollecting dill (from ivy)\n",
+            "  Downloading dill-0.3.8-py3-none-any.whl (116 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m16.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: astunparse in /usr/local/lib/python3.10/dist-packages (from ivy) (1.6.3)\n",
+            "Requirement already satisfied: ml-dtypes in /usr/local/lib/python3.10/dist-packages (from ivy) (0.2.0)\n",
+            "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from ivy) (2.2.1)\n",
+            "Requirement already satisfied: gast in /usr/local/lib/python3.10/dist-packages (from ivy) (0.5.4)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from ivy) (4.66.2)\n",
+            "Requirement already satisfied: cryptography in /usr/local/lib/python3.10/dist-packages (from ivy) (42.0.5)\n",
+            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse->ivy) (0.43.0)\n",
+            "Requirement already satisfied: six<2.0,>=1.6.1 in /usr/local/lib/python3.10/dist-packages (from astunparse->ivy) (1.16.0)\n",
+            "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.10/dist-packages (from cryptography->ivy) (1.16.0)\n",
+            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth->ivy) (5.3.3)\n",
+            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth->ivy) (0.4.0)\n",
+            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth->ivy) (4.9)\n",
+            "Requirement already satisfied: ipython>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from pyvis->ivy) (7.34.0)\n",
+            "Requirement already satisfied: jinja2>=2.9.6 in /usr/local/lib/python3.10/dist-packages (from pyvis->ivy) (3.1.3)\n",
+            "Requirement already satisfied: jsonpickle>=1.4.1 in /usr/local/lib/python3.10/dist-packages (from pyvis->ivy) (3.0.3)\n",
+            "Requirement already satisfied: networkx>=1.11 in /usr/local/lib/python3.10/dist-packages (from pyvis->ivy) (3.2.1)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->ivy) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->ivy) (3.6)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->ivy) (2024.2.2)\n",
+            "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.12->cryptography->ivy) (2.22)\n",
+            "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (67.7.2)\n",
+            "Collecting jedi>=0.16 (from ipython>=5.3.0->pyvis->ivy)\n",
+            "  Downloading jedi-0.19.1-py2.py3-none-any.whl (1.6 MB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m71.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: decorator in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (4.4.2)\n",
+            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (0.7.5)\n",
+            "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (5.7.1)\n",
+            "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (3.0.43)\n",
+            "Requirement already satisfied: pygments in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (2.16.1)\n",
+            "Requirement already satisfied: backcall in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (0.2.0)\n",
+            "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (0.1.6)\n",
+            "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.3.0->pyvis->ivy) (4.9.0)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2>=2.9.6->pyvis->ivy) (2.1.5)\n",
+            "Requirement already satisfied: pyasn1<0.7.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth->ivy) (0.6.0)\n",
+            "Requirement already satisfied: parso<0.9.0,>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from jedi>=0.16->ipython>=5.3.0->pyvis->ivy) (0.8.3)\n",
+            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.10/dist-packages (from pexpect>4.3->ipython>=5.3.0->pyvis->ivy) (0.7.0)\n",
+            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.10/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=5.3.0->pyvis->ivy) (0.2.13)\n",
+            "Installing collected packages: nvidia-ml-py, urllib3, jedi, einops, diskcache, dill, colorama, pyvis, ivy\n",
+            "  Attempting uninstall: urllib3\n",
+            "    Found existing installation: urllib3 2.0.7\n",
+            "    Uninstalling urllib3-2.0.7:\n",
+            "      Successfully uninstalled urllib3-2.0.7\n",
+            "Successfully installed colorama-0.4.6 dill-0.3.8 diskcache-5.6.3 einops-0.7.0 ivy-0.0.9.0 jedi-0.19.1 nvidia-ml-py-12.535.133 pyvis-0.3.2 urllib3-1.26.18\n"
+          ]
+        }
+      ],
+      "source": [
+        "%pip install ivy"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6kzf1d67ugpa"
+      },
+      "source": [
+        "## Introduction\n",
+        "\n",
+        "This demonstration showcases the application of **Ivy**, a unified machine learning library by [Unify](https://unify.ai/), in constructing and training a classifier to identify the presence of pneumonia from chest x-ray images. The objective is to provide a comprehensive guide through the process of model training within a medical imaging context, while emphasizing the utility and versatility of Ivy.\n",
+        "\n",
+        "### Notebook Structure\n",
+        "\n",
+        "The notebook is organized into the following sections, mirroring the typical workflow of a machine learning project:\n",
+        "\n",
+        "1. **Data Retrieval**: Acquiring the dataset necessary for training and evaluation.\n",
+        "2. **Data Exploration**: Conducting a preliminary analysis to understand the characteristics and distribution of the data.\n",
+        "3. **Data Preparation**: Preprocessing the images to facilitate effective model training.\n",
+        "4. **Model Creation**: Defining the architecture of the neural network to be used for classification.\n",
+        "5. **Model Training**: Implementing the training process, utilizing Ivy for optimization.\n",
+        "6. **Model Validation**: Evaluating the trained model's performance on a separate validation set.\n",
+        "\n",
+        "### Training Philosophy\n",
+        "\n",
+        "The primary focus of this notebook is to demonstrate the efficacy of Ivy in a practical, real-world application, rather than pushing the boundaries of model performance. Thus, we aim to train models that achieve satisfactory accuracy within a reasonable timeframe.\n",
+        "\n",
+        "These thresholds were selected to balance the trade-off between accuracy and training time. The models presented herein were trained to meet these criteria within an hour, tested on a GTX1650 (locally) and a Tesla T4 GPU (on Google Colab), making the approach accessible to a wide range of users, regardless of their hardware capabilities.\n",
+        "\n",
+        "Moreover, this notebook serves as a foundation for further experimentation. Users are encouraged to extend the training duration, tweak the model architectures, or employ more sophisticated models as needed, using the provided framework as a starting point for their explorations."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bayf-EUmr_Km"
+      },
+      "source": [
+        "## Imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jSxx8TVvr_Kn",
+        "outputId": "4dd5e07f-80d7-4890-d0fd-47c27ecfb0e1"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<module 'ivy.functional.backends.torch' from '/usr/local/lib/python3.10/dist-packages/ivy/functional/backends/torch/__init__.py'>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 2
+        }
+      ],
+      "source": [
+        "import ivy\n",
+        "import os\n",
+        "from tqdm.auto import tqdm\n",
+        "import matplotlib.pyplot as plt, numpy as np\n",
+        "import matplotlib.image as mpimg\n",
+        "%matplotlib inline\n",
+        "\n",
+        "ivy.set_backend(\"torch\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HVtNnrFyr_Ko"
+      },
+      "source": [
+        "## Download Dataset\n",
+        "The [Chest X-Ray Images (Pneumonia)](https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia) Kaggle dataset can be downloaded using the Kaggle API.\n",
+        "\n",
+        "To download the dataset from Kaggle, you need an API key which you can obtain with a Kaggle account. You would obtain a `kaggle.json` file where you would place in the root folder in a folder named `.kaggle`.\n",
+        "\n",
+        "For Google Colab users, there is a cell provided for you that allows you to upload your `kaggle.json` file and moves it to the correct directory.\n",
+        "\n",
+        "Use the cells below to install `kaggle` and download the dataset. If you already have it downloaded, you can skip this step.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "i6SycIrqr_Ko",
+        "outputId": "f5e757d8-ed2f-4790-bce0-8fb5a312987e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.5.16)\n",
+            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
+            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle) (2024.2.2)\n",
+            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.31.0)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.2)\n",
+            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.4)\n",
+            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.26.18)\n",
+            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)\n",
+            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
+            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.6)\n"
+          ]
+        }
+      ],
+      "source": [
+        "%pip install kaggle"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 92
+        },
+        "id": "7JwtV21PsFVK",
+        "outputId": "c6115143-34df-4082-8c9f-9e6770eaf971"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-d5368c4b-4e63-4e8e-af50-401756b3e23a\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-d5368c4b-4e63-4e8e-af50-401756b3e23a\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving kaggle.json to kaggle.json\n",
+            "User uploaded file \"kaggle.json\" with length 71 bytes\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Skip this cell if you are not using google colab\n",
+        "from google.colab import files\n",
+        "\n",
+        "uploaded = files.upload()\n",
+        "\n",
+        "for fn in uploaded.keys():\n",
+        "  print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
+        "      name=fn, length=len(uploaded[fn])))\n",
+        "\n",
+        "# Then move kaggle.json into the folder where the API expects to find it.\n",
+        "!mkdir -p ~/.kaggle/ && mv kaggle.json ~/.kaggle/ && chmod 600 ~/.kaggle/kaggle.json"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "p4w5GVWTr_Ko"
+      },
+      "outputs": [],
+      "source": [
+        "import kaggle\n",
+        "\n",
+        "# Ensure kaggle.json is in the proper location\n",
+        "kaggle.api.authenticate()\n",
+        "\n",
+        "# Download the dataset\n",
+        "kaggle.api.dataset_download_files('paultimothymooney/chest-xray-pneumonia', unzip=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jRPoGKpBr_Kp"
+      },
+      "source": [
+        "## List Directories\n",
+        "We investigate the downloaded dataset directory `./chest_xray`.\n",
+        "\n",
+        "Recall that in machine learning, we often use three datasets: training, validation, and testing.\n",
+        "\n",
+        "The directory structure follows this convention."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Uj_IuJ8Qr_Kp",
+        "outputId": "82f9d596-57ce-486a-e82e-94db9072f0de"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "['val', '__MACOSX', 'train', 'chest_xray', 'test']"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 6
+        }
+      ],
+      "source": [
+        "data_path = './chest_xray'\n",
+        "os.listdir(data_path)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Ybq3mofCr_Kq"
+      },
+      "source": [
+        "### Ivy's Container class\n",
+        "The `Container` class provided by Ivy is described as a *souped-up* version of the regular python dictionary.\n",
+        "\n",
+        "To store the list of files in each subfolder, it becomes extremely convenient here.\n",
+        "\n",
+        "The `train`, `test`, and `val` folders have the same directory structure, containing folders with labels:\n",
+        "- NORMAL - X-ray images of medical patients without pneumonia,\n",
+        "- PNEUMONIA - X-ray images of medical patients with pneumonia.\n",
+        "\n",
+        "We create key-value pairs where the key is the label name and the value is the list of files in that subfolder with the same name as the label.\n",
+        "\n",
+        "This is performed for the 3 folders, conveniently made concise with the use of Python's comprehensions and the `zip` function."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9Q3WpafZr_Kq",
+        "outputId": "9a5e7346-07f3-47f2-d741-9fc3296e5d5d"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'test': {'NORMAL': 234, 'PNEUMONIA': 390},\n",
+              " 'train': {'NORMAL': 1341, 'PNEUMONIA': 3875},\n",
+              " 'val': {'NORMAL': 8, 'PNEUMONIA': 8}}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 7
+        }
+      ],
+      "source": [
+        "labels = ['NORMAL','PNEUMONIA']\n",
+        "\n",
+        "file_dict = ivy.Container(\n",
+        "    {\n",
+        "        procedure : {\n",
+        "            k: v for k, v in zip(labels, [os.listdir(data_path+f'/{procedure}/'+label) for label in labels])\n",
+        "        } for procedure in ['train', 'test', 'val']\n",
+        "    }\n",
+        ")\n",
+        "\n",
+        "counts = {\n",
+        "    k: {\n",
+        "        label: len(v) for label, v in file_dict[k].items()\n",
+        "    } for k in file_dict.keys()\n",
+        "}\n",
+        "counts"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "L8wNsmUZfahM"
+      },
+      "source": [
+        "### Addressing Imbalanced Datasets\n",
+        "\n",
+        "Our dataset demonstrates a significant imbalance, with the training set containing nearly three times as many pneumonia cases as normal ones. This disparity can lead to a predictive bias in our model, where it becomes more prone to falsely identifying normal images as indicative of pneumonia.\n",
+        "\n",
+        "To counteract this imbalance, several strategies can be employed:\n",
+        "\n",
+        "- **Oversampling**: This involves replicating the minority class to balance the class distribution. While straightforward, this approach can lead to overfitting as the model repeatedly encounters identical samples during training, potentially memorizing rather than learning from them.\n",
+        "\n",
+        "- **Undersampling**: The opposite of oversampling, this method reduces the number of samples in the majority class. A major downside is the loss of potentially crucial information, as it decreases the overall size of the training dataset.\n",
+        "\n",
+        "- **Class Weighting**: This technique assigns a higher weight to the under-represented class during the loss calculation, thereby amplifying its signal and influence during model training.\n",
+        "\n",
+        "Class weighting helps in enhancing the model's sensitivity to the minority class without duplicating data or discarding valuable samples. This is the approach we've implemented to address the class imbalance in our dataset, aiming to strike a balance between recognition capability and generalization."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "EdRH9B8iD7W8",
+        "outputId": "2c011358-5460-4f97-d073-ba4aacac9f25"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(0.2570935582822086, 0.7429064417177914)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 8
+        }
+      ],
+      "source": [
+        "normal_percent = counts['train']['NORMAL']/(counts['train']['NORMAL'] + counts['train']['PNEUMONIA'])\n",
+        "pneu_percent = counts['train']['PNEUMONIA']/(counts['train']['NORMAL'] + counts['train']['PNEUMONIA'])\n",
+        "\n",
+        "normal_percent, pneu_percent"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ccztOtzYWNXF",
+        "outputId": "904220a8-7e64-4963-95a5-348796bcd150"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(15.558538404175987, 5.384258064516129)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ],
+      "source": [
+        "normal_weight, pneu_weight = 4 / (normal_percent), 4 / (pneu_percent)\n",
+        "normal_weight, pneu_weight"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "krQolZn7r_Kq"
+      },
+      "source": [
+        "### Display Random Images\n",
+        "We explore the dataset by accessing the subfolders using the convenient `/` nesting syntax that comes with `ivy.Container`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 377
+        },
+        "id": "mJw3nyfir_Kq",
+        "outputId": "79ccb924-694f-42ad-d944-872e61d93ff5"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "def display_random_images(file_dict, data_path, categories):\n",
+        "    fig, axs = plt.subplots(1, len(categories), figsize=(8, 5))\n",
+        "\n",
+        "    for idx, category in enumerate(categories):\n",
+        "        # Getting the list of files for the category\n",
+        "        files_list = file_dict[f'train/{category}']\n",
+        "\n",
+        "        # Selecting a random file\n",
+        "        random_file = files_list[np.random.randint(0, len(files_list))]\n",
+        "        img_path = f'{data_path}/train/{category}/{random_file}'\n",
+        "\n",
+        "        # Loading and displaying the image\n",
+        "        img = mpimg.imread(img_path)\n",
+        "        axs[idx].imshow(img)\n",
+        "        axs[idx].set_title(f'{category} (Shape: {img.shape})')\n",
+        "        axs[idx].axis('off')  # Hide axes ticks\n",
+        "\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "display_random_images(file_dict, data_path, labels)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4aSy2FT5r_Kr"
+      },
+      "source": [
+        "## Create Dataset\n",
+        "As of the time of writing, Ivy itself does not provide a `Dataset` class like in other frameworks like Pytorch.\n",
+        "\n",
+        "However, Ivy is designed to work with these frameworks with its backends.\n",
+        "\n",
+        "We use Pytorch's `ImageFolder` class to simplify the dataset creation for us.\n",
+        "\n",
+        "It requires the directory structure to be of the form:\n",
+        "```\n",
+        "- Directory\n",
+        "  - Category A\n",
+        "    - image1.jpg\n",
+        "    - image2.jpg\n",
+        "    - ...\n",
+        "  - Category B\n",
+        "      - image1.jpg\n",
+        "      - image2.jpg\n",
+        "      - ...\n",
+        "  -  ...\n",
+        "```\n",
+        "\n",
+        "and so on. Thankfully, our dataset directory is already structured in this way!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "Ltitlq7dr_Kr"
+      },
+      "outputs": [],
+      "source": [
+        "from copy import deepcopy\n",
+        "from torchvision import datasets\n",
+        "from torch.utils.data import Subset\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "def get_datasets(data_path, train_transforms, test_transforms, val_split=0.2):\n",
+        "    train_data = datasets.ImageFolder(os.path.join(data_path, 'train'))\n",
+        "    test_data = datasets.ImageFolder(os.path.join(data_path, 'test'), transform=test_transforms)\n",
+        "\n",
+        "    # Get the indices\n",
+        "    indices = list(range(len(train_data)))\n",
+        "\n",
+        "    # Get the targets\n",
+        "    targets = [train_data.targets[idx] for idx in indices]\n",
+        "\n",
+        "    # The given validation set is too small so we decide to split the training data to produce a validation set\n",
+        "    train_indices, val_indices, _, _ = train_test_split(indices, targets, test_size=val_split, stratify=targets)\n",
+        "\n",
+        "    # We use Subset to produce the splits with the given indices\n",
+        "    # We need to deepcopy to ensure that the transformations are not shared between the datasets\n",
+        "    val_dataset = Subset(deepcopy(train_data), val_indices)\n",
+        "    val_dataset.dataset.transform = test_transforms\n",
+        "\n",
+        "    train_dataset = Subset(train_data, train_indices)\n",
+        "    train_dataset.dataset.transform = train_transforms\n",
+        "\n",
+        "    return train_dataset, val_dataset, test_data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nhtVopJhr_Kr"
+      },
+      "source": [
+        "### Transforms\n",
+        "Ivy does not have a built-in `transforms` module like Pytorch either!\n",
+        "\n",
+        "Again, even if it did, we can still use backend-specific modules as before!\n",
+        "\n",
+        "We apply various transformations to ensure the data is of the same size, standardized, etc.\n",
+        "\n",
+        "#### Data Augmentation\n",
+        "We may need to apply various augmentations in the training data to improve regularization in some cases.\n",
+        "\n",
+        "We resize our images to 224x224 to be consistent with the input sizes of pretrained computer-vision models. Center cropping ensures that the most critical region, typically located at the center of medical images, is preserved. Horizontal flipping was also applied due to the human body's bilateral symmetry which does not alter the fundamental characteristics of the x-ray scans. We also apply small rotations to simulate variations in patient positioning during image capture.\n",
+        "\n",
+        "Standardizing pixel values based on the mean and standard deviation of the images helps in stabilizing and speeding up training by ensuring that input features are on a similar scale. The values provided originate from ImageNet, a commonly used dataset in computer-vision research."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "pVKwRp5kr_Kr"
+      },
+      "outputs": [],
+      "source": [
+        "from torchvision import transforms\n",
+        "\n",
+        "train_transforms = transforms.Compose([\n",
+        "    transforms.Resize(224),\n",
+        "    transforms.CenterCrop(224),\n",
+        "    transforms.RandomHorizontalFlip(),\n",
+        "    transforms.RandomRotation(10),\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
+        "])\n",
+        "\n",
+        "test_transforms = transforms.Compose([\n",
+        "    transforms.Resize(224),\n",
+        "    transforms.CenterCrop(224),\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])\n",
+        "])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "umV3PfcUr_Kr",
+        "outputId": "bf7e5dbc-a2a3-4ea3-ea5e-3238b0f1f910"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(4172, 1044, 624)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 13
+        }
+      ],
+      "source": [
+        "# Create the datasets with the desired transforms\n",
+        "train_data, val_data, test_data = get_datasets(data_path, train_transforms, test_transforms)\n",
+        "len(train_data), len(val_data), len(test_data)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "dlvQxPxUr_Kr"
+      },
+      "source": [
+        "### IvyDataset\n",
+        "We want our dataset to be backend-agnostic if we want to use another backend (other than `torch`).\n",
+        "\n",
+        "This can be achieved by wrapping around the `Dataset` module and ensuring that we always return `ivy.array` when fetching items.\n",
+        "\n",
+        "We make a custom `IvyDataset` class for this, and define the `__getitem__` method exactly as described."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "id": "-aN0saD8r_Ks"
+      },
+      "outputs": [],
+      "source": [
+        "from torch import tensor\n",
+        "from torch.utils.data import Dataset\n",
+        "\n",
+        "class IvyDataset:\n",
+        "    def __init__(self, dataset: Dataset):\n",
+        "        self.dataset = dataset\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.dataset)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        x, y = self.dataset[idx]\n",
+        "        # Convert the data to ivy.Array\n",
+        "        x_ivy = ivy.array(x)\n",
+        "        y_ivy = ivy.array(tensor(y))\n",
+        "        return x_ivy, y_ivy"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CIYF-EOEr_Ks"
+      },
+      "source": [
+        "#### Important Considerations\n",
+        "`ImageFolder` is derived from `Dataset`, where the targets are automatically mapped to integer indices so NORMAL and PNEUMONIA images might be labelled 0 and 1 respectively.\n",
+        "\n",
+        "However, the targets are `int` must be converted to a `tensor` so we can wrap `ivy.array` around it.\n",
+        "\n",
+        "We now have `ivy.array` items with the transforms applied, since `ImageFolder` applies the transforms whenever accessing the dataset!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d15PyeI6r_Ks",
+        "outputId": "38251564-1b89-4b28-b4e3-33c3366a9c2f"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(4172, 624)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 15
+        }
+      ],
+      "source": [
+        "train_data = IvyDataset(train_data)\n",
+        "test_data = IvyDataset(test_data)\n",
+        "\n",
+        "# check if the data adds up\n",
+        "len(train_data), len(test_data)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HycC4LObr_Ks",
+        "outputId": "08a1dc8c-7f69-4d03-ca41-7d4a86fe1456"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(ivy.Shape(3, 224, 224), ivy.array(1))"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 16
+        }
+      ],
+      "source": [
+        "x, y = train_data[0]\n",
+        "x.shape, y # x should be (3, 28, 28) and y should be a scalar"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8IsXko0yr_Ks"
+      },
+      "source": [
+        "## DataLoaders\n",
+        "We want to process the dataset in batches and also sample them randomly, so we create an `IvyDataLoader` class that functions similarly to Pytorch's `DataLoader`.\n",
+        "\n",
+        "We also add multiprocessing functionality to speed up data retrieval. You may experiment with `num_workers` to determine what works the fastest with your hardware setup."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "iIAkLIHrr_Ks"
+      },
+      "outputs": [],
+      "source": [
+        "from concurrent.futures import ThreadPoolExecutor\n",
+        "\n",
+        "class IvyDataLoader:\n",
+        "    def __init__(self, dataset, batch_size=32, shuffle=False, drop_last=False, num_workers=4):\n",
+        "        self.dataset = dataset\n",
+        "        self.batch_size = batch_size\n",
+        "        self.shuffle = shuffle\n",
+        "        self.drop_last = drop_last\n",
+        "        self.num_workers = num_workers\n",
+        "\n",
+        "    def __iter__(self):\n",
+        "        self.idx = 0\n",
+        "        self.indices = np.arange(len(self.dataset))\n",
+        "        if self.shuffle:\n",
+        "            np.random.shuffle(self.indices)\n",
+        "        if self.num_workers > 0:\n",
+        "            self.executor = ThreadPoolExecutor(max_workers=self.num_workers)\n",
+        "        else:\n",
+        "            self.executor = None\n",
+        "        return self\n",
+        "\n",
+        "    def __next__(self):\n",
+        "        if self.idx >= len(self.dataset):\n",
+        "            if self.executor:\n",
+        "                self.executor.shutdown()\n",
+        "            raise StopIteration\n",
+        "\n",
+        "        indices = self.indices[self.idx:self.idx + self.batch_size]\n",
+        "\n",
+        "        if self.executor:\n",
+        "            batch = list(self.executor.map(lambda i: self.dataset[i], indices))\n",
+        "        else:\n",
+        "            batch = [self.dataset[i] for i in indices]\n",
+        "\n",
+        "        batch_x, batch_y = zip(*batch)\n",
+        "        batch_x_ivy = ivy.concat([ivy.expand_dims(x, axis=0) for x in batch_x], axis=0)\n",
+        "        batch_y_ivy = ivy.array(batch_y)\n",
+        "        self.idx += self.batch_size\n",
+        "\n",
+        "        if len(batch_x_ivy) < self.batch_size and self.drop_last:\n",
+        "            raise StopIteration\n",
+        "\n",
+        "        return batch_x_ivy, batch_y_ivy\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        if self.drop_last:\n",
+        "            return len(self.dataset) // self.batch_size\n",
+        "        else:\n",
+        "            return (len(self.dataset) + self.batch_size - 1) // self.batch_size"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "nEy6mBkAr_Ks"
+      },
+      "outputs": [],
+      "source": [
+        "np.random.seed(42)\n",
+        "\n",
+        "num_workers = os.cpu_count()/4\n",
+        "\n",
+        "train_loader = IvyDataLoader(train_data, batch_size=32, shuffle=True, num_workers=num_workers)\n",
+        "test_loader = IvyDataLoader(test_data, batch_size=32, shuffle=False, num_workers=num_workers)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eip38w3VU0Ff",
+        "outputId": "62593b47-e241-4b64-91d7-c08ffbdaa5b2"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(131, 20)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 19
+        }
+      ],
+      "source": [
+        "len(train_loader), len(test_loader)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dRkAKnrqfahP"
+      },
+      "outputs": [],
+      "source": [
+        "# This will be slower on the first run because there is an initial overhead from starting each thread\n",
+        "# %timeit -n 10 -r 3 next(iter(train_loader))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "UUJZ0Sa4r_Kt",
+        "outputId": "f067e922-97ba-463f-ba2a-55a31d352df1"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(ivy.Shape(32, 3, 224, 224), ivy.Shape(32))"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 20
+        }
+      ],
+      "source": [
+        "xb, yb = next(iter(train_loader))\n",
+        "xb.shape, yb.shape # (batch_size, 3, 224, 224) (batch_size)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7wOlXBoyr_Kt"
+      },
+      "source": [
+        "### Show Batch\n",
+        "An convenience function `show_batch` was created which allows us to display a batch of data so that we can see the transformed data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 233
+        },
+        "id": "8c6nV1Q4r_Kt",
+        "outputId": "b208c48b-dc28-43a9-968f-3cce2557fdab"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x300 with 5 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "def show_batch(dls, class_names, num_images=5):\n",
+        "    x_batch, y_batch = next(iter(dls))\n",
+        "    fig, axes = plt.subplots(1, num_images, figsize=(15, 3))\n",
+        "    for i in range(num_images):\n",
+        "        ax = axes[i]\n",
+        "        # Convert ivy.Array back to numpy for plotting\n",
+        "        img = ivy.to_numpy(x_batch[i])\n",
+        "        label = ivy.to_numpy(y_batch[i])\n",
+        "\n",
+        "        # Transpose the image dimensions from (C, H, W) to (H, W, C)\n",
+        "        img = img.transpose((1, 2, 0))\n",
+        "\n",
+        "        # Undo the normalization for display purposes\n",
+        "        mean = np.array([0.485, 0.456, 0.406])\n",
+        "        std = np.array([0.229, 0.224, 0.225])\n",
+        "        img = std * img + mean\n",
+        "        img = np.clip(img, 0, 1)\n",
+        "\n",
+        "        ax.imshow(img)\n",
+        "        ax.set_title(class_names[label])\n",
+        "        ax.axis('off')\n",
+        "    plt.show()\n",
+        "\n",
+        "show_batch(train_loader, labels)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aBSjoJQhr_Kt"
+      },
+      "source": [
+        "## Device\n",
+        "From here onwards, we want to start using the gpu if possible to accelerate our training.\n",
+        "\n",
+        "We can simply use `ivy.set_default_device` and `ivy.set_soft_device_mode` which would skip the process entirely of needing to use `to_device` (like Pytorch's `to`) everytime we want to use data to the target device."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "8KhchLFtr_Kt"
+      },
+      "outputs": [],
+      "source": [
+        "device = \"gpu:0\" if ivy.device.gpu_is_available() else \"cpu\"\n",
+        "ivy.set_default_device(device)\n",
+        "ivy.set_soft_device_mode(True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mTuVnRm1r_Kt"
+      },
+      "source": [
+        "### Refactoring\n",
+        "If we want to change our transforms, we have to call `get_datasets` again, create an `IvyDataset` and then `IvyDataLoader`.\n",
+        "\n",
+        "We can simplify this process by combining everything into one function call."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "TMy05nEtr_Kt"
+      },
+      "outputs": [],
+      "source": [
+        "def create_dls(data_path, train_transforms, test_transforms, batch_size, random_seed=None):\n",
+        "    if random_seed is not None:\n",
+        "        np.random.seed(random_seed)\n",
+        "\n",
+        "    if isinstance(batch_size, list) and len(batch_size) != 3:\n",
+        "        raise ValueError(\"batch_size must be a single integer or a list of 3 integers.\")\n",
+        "\n",
+        "    # If batch_size is a list of 3:\n",
+        "    if isinstance(batch_size, list):\n",
+        "        train_batch_size = batch_size[0]\n",
+        "        val_batch_size = batch_size[1]\n",
+        "        test_batch_size = batch_size[2]\n",
+        "    else:\n",
+        "        train_batch_size = batch_size\n",
+        "        val_batch_size = batch_size\n",
+        "        test_batch_size = batch_size\n",
+        "\n",
+        "    # Create Datasets\n",
+        "    train_data, val_data, test_data = get_datasets(data_path, train_transforms, test_transforms)\n",
+        "\n",
+        "    # Create IvyDataLoaders\n",
+        "    train_loader = IvyDataLoader(IvyDataset(train_data), batch_size=train_batch_size, shuffle=True, num_workers=num_workers)\n",
+        "    val_loader = IvyDataLoader(IvyDataset(val_data), batch_size=val_batch_size, shuffle=False, num_workers=num_workers)\n",
+        "    test_loader = IvyDataLoader(IvyDataset(test_data), batch_size=test_batch_size, shuffle=False, num_workers=num_workers)\n",
+        "\n",
+        "    return train_loader, val_loader, test_loader\n",
+        "\n",
+        "train_loader, val_loader, test_loader = create_dls(data_path, train_transforms, test_transforms, 32, random_seed=42)\n",
+        "xb, yb = next(iter(train_loader))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fef0brrrr_Ku"
+      },
+      "source": [
+        "## Model\n",
+        "\n",
+        "We will train a classifier using Ivy by building a simple CNN (*convolutional neural network*). We can build models by subclassing the `ivy.Module` class, which functions similarly to PyTorch's `nn.Module`.\n",
+        "\n",
+        "**Key Components:**\n",
+        "\n",
+        "* **Convolutional Layers:** Extract features with learned filters.  Kernel size, stride, and padding determine the output dimensions.\n",
+        "* **Pooling Layers:** Reduce dimensionality by summarizing regions (here, max pooling takes the maximum value in each region). This helps focus on more general features.\n",
+        "* **Batch Normalization:** Improves training stability and speed by normalizing activations within each batch.\n",
+        "* **Dropout:**  Randomly turns off neurons during training to prevent the network from overfitting to the training data.\n",
+        "* **Fully Connected Layer:** Learns how to combine features for classification from the flattened output of the convolutional layers."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "ZiYUSyLqr_Ku"
+      },
+      "outputs": [],
+      "source": [
+        "class CNN(ivy.Module):\n",
+        "    def __init__(self, in_channels, dropout_rate=0.5, data_format=\"NCHW\"):\n",
+        "        self.in_channels = in_channels\n",
+        "        self.data_format = data_format\n",
+        "        self.dropout_rate = dropout_rate\n",
+        "        super().__init__()\n",
+        "\n",
+        "    def _build(self, *args, **kwargs):\n",
+        "        self.conv1 = ivy.Sequential(\n",
+        "            ivy.Conv2D(self.in_channels, 4, [3, 3], [2, 2], 1, data_format = self.data_format, with_bias=False),\n",
+        "            ivy.BatchNorm2D(4, data_format=self.data_format),\n",
+        "            ivy.ReLU()\n",
+        "        ) # 112 x 112\n",
+        "\n",
+        "        self.pool1 = ivy.MaxPool2D([2, 2], 2, 0, data_format=self.data_format)  # Output: 56 x 56\n",
+        "\n",
+        "        self.conv2 = ivy.Sequential(\n",
+        "            ivy.Conv2D(4, 8, [3, 3], [2, 2], 1, data_format = self.data_format, with_bias=False),\n",
+        "            ivy.BatchNorm2D(8, data_format=self.data_format),\n",
+        "            ivy.ReLU()\n",
+        "        ) # 28 x 28\n",
+        "\n",
+        "        self.pool2 = ivy.MaxPool2D([2, 2], 2, 0, data_format=self.data_format)  # Output: 14 x 14\n",
+        "\n",
+        "        self.lin1 = ivy.Sequential(\n",
+        "            ivy.Linear(8*14*14, 16),\n",
+        "            ivy.ReLU()\n",
+        "        )\n",
+        "\n",
+        "        self.classifier = ivy.Linear(16, 1)\n",
+        "\n",
+        "    def _forward(self, x):\n",
+        "        x = self.pool1(self.conv1(x))\n",
+        "        x = self.pool2(self.conv2(x))\n",
+        "        x = self.lin1(x.reshape((-1, 8*14*14)))\n",
+        "        x = ivy.dropout(x, self.dropout_rate, training=self.training) # dropout after linear layer to improve regularization\n",
+        "        x = self.classifier(x).squeeze(axis=-1)\n",
+        "        return x.sigmoid() # output probability"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "i61TIaFzr_Ku",
+        "outputId": "c2d51aae-a838-4e47-e7d5-6e606a7c8e26"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(ivy.Shape(32), ivy.Shape(32))"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 25
+        }
+      ],
+      "source": [
+        "model = CNN(3)\n",
+        "model.eval()\n",
+        "# Check the output shapes\n",
+        "model(xb).shape, yb.shape"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6lfxvXSY8LKy"
+      },
+      "source": [
+        "## Inference\n",
+        "The model performs a forward pass on the input images and produces a sigmoid output. This sigmoid output represents the probability of an image belonging to the pneumonia class. To obtain the final classification, we compare the sigmoid output against a predefined threshold.\n",
+        "\n",
+        "The `ivy.where` function is employed to obtain our predictions based on this threshold. If the sigmoid output exceeds the threshold, the image is classified as pneumonia; otherwise, it is classified as normal. Initially, we set the probability threshold to 0.5, which is a common starting value for binary classification tasks."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OjDY6EU9r_Ku",
+        "outputId": "52742547-242c-4522-ab82-a4e41db35212"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(ivy.array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+              "        0, 0, 0, 0, 0, 1, 0, 0, 0, 0], dev=gpu:0),\n",
+              " ivy.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n",
+              "        1, 1, 1, 1, 1, 0, 1, 1, 1, 1], dev=gpu:0))"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 26
+        }
+      ],
+      "source": [
+        "probs = model(xb)\n",
+        "class_predictions = ivy.where(probs > 0.5, 1, 0)\n",
+        "class_predictions, yb"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3b3GcObofahU"
+      },
+      "source": [
+        "### Accuracy Metric\n",
+        "To evaluate the model's performance, we calculate the accuracy by counting the number of correct predictions and dividing it by the total number of elements in the batch. The accuracy metric provides a straightforward measure of how well the model is performing on the given data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GLf2AMnIr_Ky",
+        "outputId": "f4d918f5-8080-4f97-efc8-d1e86bf526df"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "ivy.array(0.09375, dev=gpu:0)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 27
+        }
+      ],
+      "source": [
+        "(class_predictions == yb).sum() / len(yb)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "id": "1pckweN2r_Ky"
+      },
+      "outputs": [],
+      "source": [
+        "def accuracy(probs, labels):\n",
+        "    return (ivy.where(probs > 0.5, 1, 0) == labels).sum().to_scalar() / len(labels)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "N3nD85gKr_Ky",
+        "outputId": "23eb0c85-2a11-45a9-a429-5ca0589e7a59"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.09375"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 29
+        }
+      ],
+      "source": [
+        "accuracy(probs, yb)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZjBHazO3r_Ku"
+      },
+      "source": [
+        "## Training\n",
+        "### Loss Function\n",
+        "The binary cross-entropy loss is a commonly used loss function for binary classification problems, where the goal is to predict whether an input belongs to one of two classes (in our case, either \"pneumonia\" or \"normal\").\n",
+        "\n",
+        "To counteract this class imbalance issue mentioned from earlier, we introduce class weights in our loss function.\n",
+        "\n",
+        "The `weighted_binary_cross_entropy` function calculates the weighted binary cross-entropy loss by assigning different weights to the positive (pneumonia) and negative (normal) classes. The `pos_weight` and `neg_weight` parameters control the relative importance of each class during training.\n",
+        "\n",
+        "By assigning a higher weight to the underrepresented class (normal cases), the model is encouraged to pay more attention to correctly classifying the minority class examples. This helps to balance the contribution of each class to the overall loss, mitigating the impact of class imbalance on the model's performance."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jW2SpmIt8Vhz",
+        "outputId": "a2387b66-4a74-4749-d91e-724ff725b74f"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "ivy.array(6.59772226, dev=gpu:0)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 30
+        }
+      ],
+      "source": [
+        "def weighted_binary_cross_entropy(true_labels, predictions, pos_weight, neg_weight, eps=1e-5):\n",
+        "    predictions = predictions.clip(eps, 1-eps)\n",
+        "    loss_pos = -pos_weight * true_labels * ivy.log(predictions)\n",
+        "    loss_neg = -neg_weight * (1 - true_labels) * ivy.log(1 - predictions)\n",
+        "    return (loss_pos + loss_neg).mean()\n",
+        "\n",
+        "weighted_binary_cross_entropy(yb, probs, pneu_weight, normal_weight)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "id": "ysUP3nzpr_Kz"
+      },
+      "outputs": [],
+      "source": [
+        "def loss_fn(params):\n",
+        "    v, model, x, y = params\n",
+        "    probs = model(x, v=v)\n",
+        "    return weighted_binary_cross_entropy(y, probs, pneu_weight, normal_weight)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "k37x_Omfr_Kz",
+        "outputId": "54ddcb71-6404-46e1-abfd-91335c78aa86"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "ivy.array(6.59772226, dev=gpu:0)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 32
+        }
+      ],
+      "source": [
+        "loss_fn((None, model, xb, yb))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "07h9JjelfahV"
+      },
+      "source": [
+        "### Training and Validation\n",
+        "The `train_step` function performs a forward pass on the input data (`xb`) using the provided model, calculates the loss and gradients using the `loss_fn`, updates the model's parameters using the optimizer, and returns the loss and accuracy for the current batch.\n",
+        "\n",
+        "The `test_step` function is similar to `train_step`, but it only calculates the loss and accuracy without updating the model's parameters, as it's used for evaluation purposes."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 33,
+      "metadata": {
+        "id": "-ofqLhqFr_Kz"
+      },
+      "outputs": [],
+      "source": [
+        "def train_step(xb, yb, model, optimizer):\n",
+        "    probs = model(xb)\n",
+        "    loss, grads = ivy.execute_with_gradients(\n",
+        "        loss_fn,\n",
+        "        (model.v, model, xb, yb)\n",
+        "    )\n",
+        "\n",
+        "    model.v = optimizer.step(model.v, grads)\n",
+        "\n",
+        "    return loss.to_scalar(), accuracy(probs, yb)\n",
+        "\n",
+        "def test_step(xb, yb, model):\n",
+        "    probs = model(xb)\n",
+        "    loss = loss_fn((None, model, xb, yb))\n",
+        "\n",
+        "    return loss.to_scalar(), accuracy(probs, yb)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7fgb9fzbfahW"
+      },
+      "source": [
+        "### Model Fitting\n",
+        "The `fit` function runs the training and validation loops over multiple epochs. It uses a dictionary `results` to store the training and validation metrics (loss and accuracy) for each epoch.\n",
+        "\n",
+        "In each epoch, the function initializes variables to accumulate the total loss and accuracy for both training and validation sets. It uses a unified progress bar (`tqdm`) to display the current epoch, loss, and accuracy during training and validation.\n",
+        "\n",
+        "To account for specific layers that function differently during training and evaluation (e.g., dropout), we use `model.train()` and `model.eval()` to switch between modes. `ivy.Module` (the class our model inherits from) uses these functions to control a `training` flag to achieve this intended purpose.\n",
+        "\n",
+        "After completing both training and validation phases, the function calculates the average loss and accuracy for the epoch by dividing the accumulated metrics by the total number of samples. These average metrics are then appended to the `results` dictionary and displayed in the progress bar."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "id": "brYhbZBqfahW"
+      },
+      "outputs": [],
+      "source": [
+        "def fit(epochs, train_dls, val_dls, model, optimizer, results):\n",
+        "    if not results:\n",
+        "        # Initialize results dictionary\n",
+        "        results = {'train_loss': [], 'train_acc': [], 'val_loss': [], 'val_acc': []}\n",
+        "\n",
+        "    # Calculate total steps per epoch (train + test batches)\n",
+        "    total_steps_per_epoch = len(train_dls) + len(val_dls)\n",
+        "\n",
+        "    try:\n",
+        "        for epoch in range(epochs):\n",
+        "            # Initialize metrics\n",
+        "            total_train_loss = 0.0\n",
+        "            total_train_acc = 0.0\n",
+        "            total_val_loss = 0.0\n",
+        "            total_val_acc = 0.0\n",
+        "\n",
+        "            # Unified progress bar for both training and testing\n",
+        "            unified_loop = tqdm(range(total_steps_per_epoch), desc=f'Epoch {epoch + 1}/{epochs}', leave=True, position=0)\n",
+        "\n",
+        "            # Training phase\n",
+        "            model.train()\n",
+        "            for xb, yb in train_dls:\n",
+        "                train_loss, train_accuracy = train_step(xb, yb, model, optimizer)\n",
+        "                total_train_loss += (train_loss * xb.shape[0])\n",
+        "                total_train_acc += train_accuracy\n",
+        "\n",
+        "                unified_loop.set_postfix_str(f\"(Train) loss: {train_loss:.4f}, acc: {train_accuracy:.4f}\")\n",
+        "                unified_loop.update(1)  # Update progress after each training batch\n",
+        "\n",
+        "            # Testing phase\n",
+        "            model.eval()\n",
+        "            for xb, yb in val_dls:\n",
+        "                val_loss, val_accuracy = test_step(xb, yb, model)\n",
+        "                total_val_loss += (val_loss * xb.shape[0])\n",
+        "                total_val_acc += val_accuracy\n",
+        "\n",
+        "                unified_loop.set_postfix_str(f\"(Val) loss: {val_loss:.4f}, acc: {val_accuracy:.4f}\")\n",
+        "                unified_loop.update(1)  # Update progress after each test batch\n",
+        "\n",
+        "            # Calculate average metrics for the epoch\n",
+        "            avg_train_loss = total_train_loss / (len(train_dls) * train_dls.batch_size)\n",
+        "            avg_train_acc = total_train_acc / len(train_dls)\n",
+        "            avg_val_loss = total_val_loss / (len(val_dls) * val_dls.batch_size)\n",
+        "            avg_val_acc = total_val_acc / len(val_dls)\n",
+        "\n",
+        "            # Update results and progress bar postfix\n",
+        "            results['train_loss'].append(avg_train_loss)\n",
+        "            results['train_acc'].append(avg_train_acc)\n",
+        "            results['val_loss'].append(avg_val_loss)\n",
+        "            results['val_acc'].append(avg_val_acc)\n",
+        "\n",
+        "            unified_loop.set_postfix(train_loss=avg_train_loss, train_acc=avg_train_acc, val_loss=avg_val_loss, val_acc=avg_val_acc)\n",
+        "    except KeyboardInterrupt:\n",
+        "        # Catch the keyboard interrupt and exit the training loop gracefully\n",
+        "        print(f\"\\nTraining interrupted at epoch {epoch+1}.\")\n",
+        "    finally:\n",
+        "        print(f\"Training completed at epoch {epoch+1}.\")\n",
+        "\n",
+        "    return results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "id": "8ZZYoa2Vr_Kz"
+      },
+      "outputs": [],
+      "source": [
+        "def plot_training_results(results):\n",
+        "    epochs = range(1, len(results['train_loss']) + 1)\n",
+        "\n",
+        "    plt.figure(figsize=(12, 5))\n",
+        "\n",
+        "    # Plot training and validation loss\n",
+        "    plt.subplot(1, 2, 1)\n",
+        "    plt.plot(epochs, results['train_loss'], label='Training Loss')\n",
+        "    plt.plot(epochs, results['val_loss'], label='Validation Loss')\n",
+        "    plt.title('Training and Validation Loss')\n",
+        "    plt.xlabel('Epoch')\n",
+        "    plt.ylabel('Loss')\n",
+        "    plt.legend()\n",
+        "\n",
+        "    # Plot training and validation accuracy\n",
+        "    plt.subplot(1, 2, 2)\n",
+        "    plt.plot(epochs, results['train_acc'], label='Training Accuracy')\n",
+        "    plt.plot(epochs, results['val_acc'], label='Validation Accuracy')\n",
+        "    plt.title('Training and Validation Accuracy')\n",
+        "    plt.xlabel('Epoch')\n",
+        "    plt.ylabel('Accuracy')\n",
+        "    plt.legend()\n",
+        "\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "id": "8J3TQSFTr_Kz"
+      },
+      "outputs": [],
+      "source": [
+        "results = {}\n",
+        "optimizer = ivy.AdamW(lr=1e-3, weight_decay=1e-2) # We use AdamW for fast learning and a high weight decay to improve regularization"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 195,
+          "referenced_widgets": [
+            "2b64ca6bcf4c4c79a655289f69364a44",
+            "20d886f418bc4b70ab2734c5790cbc16",
+            "848d5b4533d646f58ff5153b7e5a9f01",
+            "bfe19b42bcdd40a487373d05d4161000",
+            "0c078a29235845569c7a51f03d5a11fc",
+            "2baa86f302b140ea8c42df4665a39c24",
+            "75b888579f4142d6985d80c21f69e874",
+            "f208f20a7d0c4043be84d2cd3ef137b3",
+            "45d41d08d03c40f4878b2040c8beb834",
+            "77f04b28b3564c9a9fe7afd2b47b4432",
+            "bb3af45c886f48a9a1d64d31f50f047e",
+            "4cfcc1ebe10047798453c86a8d267336",
+            "33181f1f28ba42498ae9f8b0b9895d47",
+            "6cebd409464448fca32bb0c84aa11237",
+            "19d51182bf354bd2a1ec01c390e69bd1",
+            "a9588f5a68bb445998893f0b81f9bd6c",
+            "507e3879969c40b88537146c8add6877",
+            "6310ee08bba44547b4e843de6a6333f2",
+            "edea008acaff491c99dff03b5aa96a20",
+            "ade2d223dad445e6a30e943e25309b5a",
+            "d29f716fe5934c64bf609203d2628839",
+            "067537d80e204586bd88f69a72e287f5",
+            "d20542e0f64845ce8224eb9da7c984b1",
+            "24074a47196e48189381e5482e644bd1",
+            "0989e92e4b0648bebfea0c77a27159f4",
+            "90e9fa8000a348c1b767e1a1d9ee2a4c",
+            "78b75313c22f4a788f0b3c1002a42b08",
+            "3c0ecd26f61144d1b581da6423244610",
+            "9996833482a34d979878b171f232b306",
+            "58d08253ad4741afa294cb476597b450",
+            "fd55ef7b5f2646eea3c9eb9123e2cce2",
+            "a1b13e2a1a8f4430b1064a3e96758461",
+            "e91ea0854d9047aba2f4f6767f84dbca",
+            "174e32b6c33246f88ed28079a9b85a9f",
+            "5b453cbe2d5b4a458ff0b0b01a1dbfbd",
+            "9f89553ec0ac4cb09446e7f3042ae54b",
+            "124f6de22f1c4b68bf3db51add98ccae",
+            "af7a51cd749b4381ad9b2f93f3575303",
+            "bce21439b7f34c9eb0c7bb819c3b456c",
+            "b8f86628fe8946edba6c18b77129f5cc",
+            "4448ee695a2b49739608d5d63ab683f9",
+            "46445c615bf44a14860046004d2bac03",
+            "6e9794958a7241de874513820b1b6282",
+            "8507f3d967d4484fb9a5b4a330b36b81",
+            "cf7be78018ac4c05be4e248c9dc64b72",
+            "e0a882be186d46ab94b32014ff912c10",
+            "23beac6bc6ee4f4787d3c18bfe530d19",
+            "4132f61fd9fc4fa8b96d0170c87b1db8",
+            "4f6557a722b24e68967393203217a521",
+            "7f7ad79be0b044bdb42850cc6ab81322",
+            "7818092a45c449178b9112fb83284d79",
+            "1134c3d12bd5490e84bf8d737df8a140",
+            "4b5c8c748fd14e94a0a0258f702e5c7e",
+            "bff74127b62842ac81bd5ab1ff37335e",
+            "b8a22d7541ad4272abc76cb789a857e2"
+          ]
+        },
+        "id": "RDovg9gGr_K0",
+        "outputId": "3b1aab76-63a4-46a5-f622-01af46958d7c"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Epoch 1/5:   0%|          | 0/164 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "2b64ca6bcf4c4c79a655289f69364a44"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Epoch 2/5:   0%|          | 0/164 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "4cfcc1ebe10047798453c86a8d267336"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Epoch 3/5:   0%|          | 0/164 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "d20542e0f64845ce8224eb9da7c984b1"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Epoch 4/5:   0%|          | 0/164 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "174e32b6c33246f88ed28079a9b85a9f"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Epoch 5/5:   0%|          | 0/164 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "cf7be78018ac4c05be4e248c9dc64b72"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Training completed at epoch 5.\n"
+          ]
+        }
+      ],
+      "source": [
+        "num_epochs = 5\n",
+        "results = fit(num_epochs, train_loader, val_loader, model, optimizer, results)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 453
+        },
+        "id": "F7O_5w5RDG7c",
+        "outputId": "28078fd1-db09-4fd3-eec0-d2520ac6ca02"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plot_training_results(results)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "z0qv-gLtr_K0"
+      },
+      "source": [
+        "### Saving our Trained Model\n",
+        "\n",
+        "An `ivy.Module` object contains the trained weights stored in its `v` property. It is an `ivy.Container` object, which provides various methods for saving the data to disk.\n",
+        "\n",
+        "We can save our trained model using different output formats. In this case, we are using the 'hdf5' format by invoking the `cont_to_disk_as_hdf5` method.\n",
+        "\n",
+        "The 'w' mode is specified as the argument, so that the weights can be overwritten if the file already exists; otherwise, the file will be created if it does not exist."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 39,
+      "metadata": {
+        "id": "kmX-Z_k1fahX"
+      },
+      "outputs": [],
+      "source": [
+        "model.v.cont_to_disk_as_hdf5('your_weights.hdf5', mode='w')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bxP8s2pCfahX"
+      },
+      "source": [
+        "### Loading our Model\n",
+        "To load our pre-trained model, we utilize the `cont_to_disk_as_hdf5` method, which allows us to directly assign the pre-trained weights to the `.v` property of an `ivy.Module` object, such as a CNN.\n",
+        "\n",
+        "For convenience, we provide a default weights file named `weights.hdf5`. This file can be used if you have not performed the training steps and wish to use a model that has already been trained.\n",
+        "\n",
+        "Before loading the weights into the model, ensure that the model is in evaluation mode. This is an important step as it disables layers like dropout, and ensures that batch normalization layers use the running means and standard deviations from the training phase, replicating the exact state of the saved model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MqTc19hkalnE",
+        "outputId": "513d332f-adf1-443d-d580-e292fb5fcc34"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/ivy/functional/backends/torch/creation.py:131: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:275.)\n",
+            "  ret = torch.as_tensor(obj, dtype=dtype, device=device)\n"
+          ]
+        }
+      ],
+      "source": [
+        "loaded = ivy.Container.cont_from_disk_as_hdf5('weights.hdf5')\n",
+        "\n",
+        "loaded_model = CNN(3)\n",
+        "loaded_model.eval()\n",
+        "loaded_model.v = loaded"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CTLAldksfahY"
+      },
+      "source": [
+        "## Model Evaluation\n",
+        "\n",
+        "We'll use a classification report and a confusion matrix to evaluate our model's performance. These provide a clear picture of how well it classifies data.\n",
+        "\n",
+        "### Classification Report\n",
+        "\n",
+        "A classification report includes several metrics, such as precision, recall, F1-score, and support for each class. This report is converted to a pandas DataFrame for better readability and potential further analysis.\n",
+        "\n",
+        "### Confusion Matrix\n",
+        "\n",
+        "A confusion matrix shows how our model's predictions fall into these categories:\n",
+        "\n",
+        "* **True Positives:** Correctly predicted positive cases\n",
+        "* **False Positives:** Incorrectly predicted positive cases\n",
+        "* **True Negatives:** Correctly predicted negative cases\n",
+        "* **False Negatives:** Incorrectly predicted negative cases\n",
+        "\n",
+        "This helps us see where the model might be making mistakes.\n",
+        "\n",
+        "### Threshold Optimization\n",
+        "\n",
+        "Our model uses a threshold to decide when a predicted probability counts as a positive classification. The default threshold is 0.5, but this can be adjusted. After testing, we determined that a threshold of 0.45 works best for our specific model and dataset by achieving the best overall results.  "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 41,
+      "metadata": {
+        "id": "c5-9Evvur_K1"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import classification_report, confusion_matrix\n",
+        "import pandas as pd\n",
+        "\n",
+        "def evaluate_model(model, test_loader, threshold=0.5):\n",
+        "    all_preds = []\n",
+        "    all_labels = []\n",
+        "\n",
+        "    # Ensure the threshold is between 0 and 1\n",
+        "    if not 0 <= threshold <= 1:\n",
+        "        raise ValueError(\"Threshold must be between 0 and 1\")\n",
+        "\n",
+        "    # Loop over the entire test dataset\n",
+        "    for xb, yb in test_loader:\n",
+        "        # Generate predictions using the provided model and threshold\n",
+        "        probs = model(xb)\n",
+        "        preds = ivy.where(probs > threshold, 1, 0)\n",
+        "        all_preds.extend(preds.tolist())\n",
+        "        all_labels.extend(yb.tolist())\n",
+        "\n",
+        "    # Convert lists to a NumPy array for confusion matrix computation\n",
+        "    all_preds = np.array(all_preds)\n",
+        "    all_labels = np.array(all_labels)\n",
+        "\n",
+        "    # Compute the confusion matrix\n",
+        "    cm = confusion_matrix(all_labels, all_preds)\n",
+        "\n",
+        "    # Generate a classification report\n",
+        "    report = classification_report(all_labels, all_preds, output_dict=True)\n",
+        "\n",
+        "    # Convert the report to a pandas DataFrame\n",
+        "    df_report = pd.DataFrame(report).transpose()\n",
+        "\n",
+        "    return cm, df_report\n",
+        "\n",
+        "cm, df_report = evaluate_model(loaded_model, test_loader, 0.45)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 42,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "tPyHvaEsfahY",
+        "outputId": "fd83ae42-f813-48e7-dbee-f5e66b4b893c"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "              precision    recall  f1-score     support\n",
+              "0              0.735426  0.700855  0.717724  234.000000\n",
+              "1              0.825436  0.848718  0.836915  390.000000\n",
+              "accuracy       0.793269  0.793269  0.793269    0.793269\n",
+              "macro avg      0.780431  0.774786  0.777320  624.000000\n",
+              "weighted avg   0.791683  0.793269  0.792219  624.000000"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-08de31c2-c1c7-4f2e-863f-c24d38e76d1a\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>precision</th>\n",
+              "      <th>recall</th>\n",
+              "      <th>f1-score</th>\n",
+              "      <th>support</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0.735426</td>\n",
+              "      <td>0.700855</td>\n",
+              "      <td>0.717724</td>\n",
+              "      <td>234.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>0.825436</td>\n",
+              "      <td>0.848718</td>\n",
+              "      <td>0.836915</td>\n",
+              "      <td>390.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>accuracy</th>\n",
+              "      <td>0.793269</td>\n",
+              "      <td>0.793269</td>\n",
+              "      <td>0.793269</td>\n",
+              "      <td>0.793269</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>macro avg</th>\n",
+              "      <td>0.780431</td>\n",
+              "      <td>0.774786</td>\n",
+              "      <td>0.777320</td>\n",
+              "      <td>624.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>weighted avg</th>\n",
+              "      <td>0.791683</td>\n",
+              "      <td>0.793269</td>\n",
+              "      <td>0.792219</td>\n",
+              "      <td>624.000000</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-08de31c2-c1c7-4f2e-863f-c24d38e76d1a')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-08de31c2-c1c7-4f2e-863f-c24d38e76d1a button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-08de31c2-c1c7-4f2e-863f-c24d38e76d1a');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-0982534b-ba8e-4f88-a387-85038d3d84ff\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-0982534b-ba8e-4f88-a387-85038d3d84ff')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-0982534b-ba8e-4f88-a387-85038d3d84ff button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "\n",
+              "  <div id=\"id_ebc68e72-d709-4d09-94af-55eec3508202\">\n",
+              "    <style>\n",
+              "      .colab-df-generate {\n",
+              "        background-color: #E8F0FE;\n",
+              "        border: none;\n",
+              "        border-radius: 50%;\n",
+              "        cursor: pointer;\n",
+              "        display: none;\n",
+              "        fill: #1967D2;\n",
+              "        height: 32px;\n",
+              "        padding: 0 0 0 0;\n",
+              "        width: 32px;\n",
+              "      }\n",
+              "\n",
+              "      .colab-df-generate:hover {\n",
+              "        background-color: #E2EBFA;\n",
+              "        box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "        fill: #174EA6;\n",
+              "      }\n",
+              "\n",
+              "      [theme=dark] .colab-df-generate {\n",
+              "        background-color: #3B4455;\n",
+              "        fill: #D2E3FC;\n",
+              "      }\n",
+              "\n",
+              "      [theme=dark] .colab-df-generate:hover {\n",
+              "        background-color: #434B5C;\n",
+              "        box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "        filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "        fill: #FFFFFF;\n",
+              "      }\n",
+              "    </style>\n",
+              "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('df_report')\"\n",
+              "            title=\"Generate code using this dataframe.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "    <script>\n",
+              "      (() => {\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#id_ebc68e72-d709-4d09-94af-55eec3508202 button.colab-df-generate');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      buttonEl.onclick = () => {\n",
+              "        google.colab.notebook.generateWithVariable('df_report');\n",
+              "      }\n",
+              "      })();\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "dataframe",
+              "variable_name": "df_report",
+              "summary": "{\n  \"name\": \"df_report\",\n  \"rows\": 5,\n  \"fields\": [\n    {\n      \"column\": \"precision\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.03250493626092942,\n        \"min\": 0.7354260089686099,\n        \"max\": 0.8254364089775561,\n        \"num_unique_values\": 5,\n        \"samples\": [\n          0.8254364089775561,\n          0.7916825089742013,\n          0.7932692307692307\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"recall\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.053248735690675494,\n        \"min\": 0.7008547008547008,\n        \"max\": 0.8487179487179487,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.8487179487179487,\n          0.7747863247863247,\n          0.7008547008547008\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"f1-score\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.04298047697505762,\n        \"min\": 0.7177242888402624,\n        \"max\": 0.8369152970922882,\n        \"num_unique_values\": 5,\n        \"samples\": [\n          0.8369152970922882,\n          0.7922186689977786,\n          0.7932692307692307\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"support\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 266.5228430270368,\n        \"min\": 0.7932692307692307,\n        \"max\": 624.0,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          390.0,\n          624.0,\n          234.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+            }
+          },
+          "metadata": {},
+          "execution_count": 42
+        }
+      ],
+      "source": [
+        "df_report"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 43,
+      "metadata": {
+        "id": "NjNK87lPr_K1",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "outputId": "f6b9f8a5-6653-4d36-b088-4a281dd59dac"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAGwCAYAAABM/qr1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABF5klEQVR4nO3dd3xUVf7/8fek9wSCaRCaIUhHUTEWBARCUxRWRQHDAu6KwArSXUHAhaDIovBDWN1AwC9FRGlZFREJRRAFRSwIElAQElBKAtHUub8/SEYvCZBhJhliXs/H4zzWuefcM59hUz75nHPvtRiGYQgAAAByc3UAAAAA1woSIwAAgCIkRgAAAEVIjAAAAIqQGAEAABQhMQIAAChCYgQAAFDEw9UBoOJYrVYdP35cgYGBslgsrg4HAGAHwzB07tw5RUVFyc2t/OoaOTk5ysvLc8pcXl5e8vHxccpcFYXEqAo5fvy4oqOjXR0GAMABR48eVa1atcpl7pycHNWrE6CMk4VOmS8iIkKHDx+uVMkRiVEVEhgYKElq8PeJcveqPF+kgD1qLvrW1SEA5aLAyNPmcytsP8vLQ15enjJOFurH3XUVFOhYVSrrnFV1Wv2gvLw8EiNcm4qXz9y9fOTuXXm+SAF7eFi8XB0CUK4qYitEQKBFAYGOvY9VlXPLBokRAAAwKTSsKnTwSaqFhtU5wVQwEiMAAGBilSGrHMuMHD3fVbhcHwAAoAgVIwAAYGKVVY4uhDk+g2uQGAEAAJNCw1Ch4dhSmKPnuwpLaQAAAEWoGAEAAJOqvPmaxAgAAJhYZaiwiiZGLKUBAAAUoWIEAABMWEoDAAAowlVpAAAAoGIEAADMrEXN0TkqIxIjAABgUuiEq9IcPd9VSIwAAIBJoXGhOTpHZcQeIwAAgCJUjAAAgAl7jAAAAIpYZVGhLA7PURmxlAYAAFCEihEAADCxGheao3NURiRGAADApNAJS2mOnu8qLKUBAAAUoWIEAABMqnLFiMQIAACYWA2LrIaDV6U5eL6rsJQGAABQhIoRAAAwYSkNAACgSKHcVOjgolKhk2KpaCRGAADAxHDCHiODPUYAAACVGxUjAABgwh4jAACAIoWGmwoNB/cYVdJHgrCUBgAAUISKEQAAMLHKIquDtROrKmfJiMQIAACYVOU9RiylAQAAFKFiBAAATJyz+bpyLqVRMQIAACYX9hg53spq3rx5at68uYKCghQUFKS4uDi99957tv6cnBwNGTJEoaGhCggIUK9evXTixAnTHEeOHFG3bt3k5+ensLAwjR49WgUFBXZ/dhIjAADgUrVq1dL06dO1e/du7dq1S+3bt1ePHj30zTffSJJGjBihdevW6a233tLmzZt1/Phx9ezZ03Z+YWGhunXrpry8PG3fvl2LFi1ScnKyJk6caHcsFsOopLUu2C0rK0vBwcG6Ydg0uXv7uDocoFzUev1rV4cAlIsCI08bs/5PmZmZCgoKKpf3KP498daXN8gv0N2huX49V6gHW3yno0ePmuL19vaWt7f3Fc+vXr26ZsyYob/85S+67rrrtHTpUv3lL3+RJH333Xdq1KiRduzYodtuu03vvfeeunfvruPHjys8PFySNH/+fI0dO1Y///yzvLy8yhw3FSMAAGBSvMfI0SZJ0dHRCg4OtrXExMTLv3dhoZYvX67s7GzFxcVp9+7dys/PV4cOHWxjbrjhBtWuXVs7duyQJO3YsUPNmjWzJUWSFB8fr6ysLFvVqazYfA0AAEyscnPafYxKqxiV5quvvlJcXJxycnIUEBCgVatWqXHjxtqzZ4+8vLwUEhJiGh8eHq6MjAxJUkZGhikpKu4v7rMHiREAACg3xRuqr6Rhw4bas2ePMjMztXLlSiUkJGjz5s0VEKEZiREAADApNCwqNBy8waOd53t5eSkmJkaS1KpVK3322Wd65ZVX9PDDDysvL09nz541VY1OnDihiIgISVJERIQ+/fRT03zFV60Vjykr9hgBAACTQrk5pTnCarUqNzdXrVq1kqenpzZu3Gjr279/v44cOaK4uDhJUlxcnL766iudPHnSNmbDhg0KCgpS48aN7XpfKkYAAMClxo8fry5duqh27do6d+6cli5dqtTUVK1fv17BwcEaOHCgnn76aVWvXl1BQUEaNmyY4uLidNttt0mSOnXqpMaNG6tfv3568cUXlZGRoWeffVZDhgwp0xVwf0RiBAAATKyGm6wO3vnaasfdgE6ePKnHHntM6enpCg4OVvPmzbV+/Xp17NhRkjRr1iy5ubmpV69eys3NVXx8vF599VXb+e7u7kpJSdHgwYMVFxcnf39/JSQkaMqUKXbHTWIEAABMnLEUVqiyJ0ZJSUmX7ffx8dHcuXM1d+7cS46pU6eO3n333TK/56WwxwgAAKAIFSMAAGBilf1XlZU2R2VEYgQAAEycc4PHyrkoVTmjBgAAKAdUjAAAgMkfn3XmyByVEYkRAAAwscoiqxzdY+TY+a5CYgQAAEyqcsWockYNAABQDqgYAQAAE+fc4LFy1l5IjAAAgInVsMjq6H2MHDzfVSpnOgcAAFAOqBgBAAATqxOW0irrDR5JjAAAgInVcJPVwavKHD3fVSpn1AAAAOWAihEAADAplEWFDt6g0dHzXYXECAAAmLCUBgAAACpGAADArFCOL4UVOieUCkdiBAAATKryUhqJEQAAMOEhsgAAAKBiBAAAzAxZZHVwj5HB5foAAODPgKU0AAAAUDECAABmVsMiq+HYUpij57sKiREAADAplJsKHVxUcvR8V6mcUQMAAJQDKkYAAMCEpTQAAIAiVrnJ6uCikqPnu0rljBoAAKAcUDECAAAmhYZFhQ4uhTl6vquQGAEAABP2GAEAABQxDDdZHbxztcGdrwEAACo3KkYAAMCkUBYVOvgQWEfPdxUSIwAAYGI1HN8jZDWcFEwFYykNAACgCBUjwA6tah5X/1v2qFH4zwoL+FVPremsTQfrmcbUq35GI9rsUKta6fJwsyrtVDU9vTZeGecCL5rN0Ks9/6c76x0tdR7gWrBw46cKr5lb4njKkki9+nyMPL2senzsIbXp9rM8Pa36/ONqmjs5RmdPebkgWjiL1Qmbrx0931VIjAA7+Hrma//PoVr19Q16ucf6Ev21gjO1qPcqrfq6kV7dfovO53oppsZp5RW4lxjb96a9Mirp5ayoOp76S0u5/+HLt06DbE1b+LW2rq8hSfrb+DTdcvcZJT7VSNnn3TV4QpqenbNPox5t4aKI4QxWWWR1cI+Qo+e7SuVM58qof//+slgsmj59uun46tWrZbH8/n9YYWGhZs2apWbNmsnHx0fVqlVTly5d9PHHH5vOS05OlsVikcVikZubmyIjI/Xwww/ryJEjpnFt27Yt9X0lqVu3brJYLJo0aVKJvmXLlsnd3V1Dhgwp0ZeamiqLxaKzZ8/a8S8AZ9v2Qx39v49b66OD9UvtH3bnp9p6uI5mbYnTdyev00+ZwUpNq6fTv/mZxjW87hcl3PylJq5vVxFhA1ct64yXzvzye7u17Wkd/9FHX30aLL+AAnXqdUKvv1BPX+4M0cFvAjVrfKwa35Slhi2yXB06cFX+1ImRJPn4+OiFF17QmTNnSu03DEO9e/fWlClT9NRTT2nfvn1KTU1VdHS02rZtq9WrV5vGBwUFKT09XceOHdPbb7+t/fv368EHHywxb3R0tJKTk03Hjh07po0bNyoyMrLUWJKSkjRmzBgtW7ZMOTk5V/V54ToWGWpT/0f9eCZY83qlKHXwQi159G21izlsGufjka/p3T7U1I136dSvfpeYDbj2eHha1e6+k/rgnXBJFjVocl6eXob2bK9mG/PTYT+dPOatRi3PuS5QOKz4zteOtsroT58YdejQQREREUpMTCy1f8WKFVq5cqUWL16sQYMGqV69emrRooVee+013XfffRo0aJCys7Nt4y0WiyIiIhQZGanbb79dAwcO1KeffqqsLPNfR927d9cvv/xiqjotWrRInTp1UlhYWIk4Dh8+rO3bt2vcuHGKjY3VO++846R/AVSU6n6/yd8rXwNv/UIfH47W31feq40H62nWfe+rVa3jtnGj227Xl8fDlZrGniJULnH3nFJAYIE+XBUuSap2XZ7y8yzKPmfelXHmlKeq1chzRYhwkuI9Ro62yqhyRm0Hd3d3TZs2TXPmzNFPP/1Uon/p0qWKjY3VvffeW6Jv5MiROnXqlDZs2FDq3CdPntSqVavk7u4ud3fzHhIvLy/16dNHCxcutB1LTk7WgAEDSp1r4cKF6tatm4KDg9W3b18lJSXZ8zFLlZubq6ysLFND+XGzXLg2ddPBuvq/z1to/881tODTm7TlUB091OIbSVLb6w/r1trH9MKmO10ZKnBVOv0lQ7u2Vtfpk96uDgUoN3/6xEiSHnjgAbVs2VLPPfdcib4DBw6oUaNGpZ5XfPzAgQO2Y5mZmQoICJC/v7/Cw8O1adMmDRkyRP7+/iXOHzBggFasWKHs7Gxt2bJFmZmZ6t69e4lxVqtVycnJ6tu3rySpd+/e2rZtmw4fPlxirD0SExMVHBxsa9HR0Q7Nh8s785uP8gvdlHaquun4oVPVFBF4XpJ0a/QxRYdk6uOhSfp8xHx9PmK+JOnf965X0kNrKjxmoKzConLUMu6s1r8VYTt25mcveXoZ8g8sMI2tFpqvM79wVVplZpXF9ry0q26VdPN1lbkq7YUXXlD79u01atSoEn2GUfa7UAUGBurzzz9Xfn6+3nvvPS1ZskRTp04tdWyLFi3UoEEDrVy5Ups2bVK/fv3k4VHyn3zDhg3Kzs5W165dJUk1atRQx44dtWDBAj3//PNlju1i48eP19NPP217nZWVRXJUjgqs7vrmxHWqW/2s6XidaplKzwqQJCV9epPe+cqciL/Tf4VmpN6uzWl1KyhSwH4de55Q5ilPfbr598T/+28ClJ9nUcu4s/r4gwtXqdWs96vCauZq356Lb0+BysRwwlVpBonRta1NmzaKj4/X+PHj1b9/f9vx2NhY7du3r9Rzio/Hxsbajrm5uSkmJkbShYpSWlqaBg8erDfeeKPUOQYMGKC5c+fq22+/1aefflrqmKSkJJ0+fVq+vr62Y1arVXv37tXkyZPl5nZ1hT1vb295e1PydiZfz3zVDsm0va4ZlKWG1/2izBxvZZwLVPJnLTWj+wZ9/lOkPj1aU3fUPaK7r/9BA1f0kCSd+tWv1A3X6ecCdSwrqMI+B2APi8VQxwdO6MPV4bIW/v7L7tfzHvrg7XA9PvaQzmV66Nfz7nri2TR9+0Wg9n/J13NlVlz1cXSOyqjKJEaSNH36dLVs2VINGza0Hevdu7ceffRRrVu3rsQ+o5kzZyo0NFQdO3a85Jzjxo3T9ddfrxEjRuimm24q0f/oo49q1KhRatGihRo3blyi/9SpU1qzZo2WL1+uJk2a2I4XFhbqzjvv1AcffKDOnTtfzcdFOWgSflILHl5rez2m3XZJ0pqvG2rC+vb66GB9Pf9hGw289QuNbbdNP5wJ0dNr4/XFsdKvRAQqg5a3n1VYzVxteCe8RN9ridfLsB7SP1/ZJ08vq3Zvq6ZXp8S4IErAOapUYtSsWTP16dNHs2fPth3r3bu33nrrLSUkJGjGjBm65557lJWVpblz52rt2rV66623St0/VCw6OloPPPCAJk6cqJSUlBL91apVU3p6ujw9PUs9/4033lBoaKgeeugh072VJKlr165KSkoyJUZfffWVAgN/L1FbLBa1aMGN1CrKrp9qqvnMwZcds/rrRlr9den71kpzpfkAV/vi42rqesNdpfbl57np1edj9OrzJEN/Jtz5ugqZMmWK3nzzTdtri8WiFStW6OWXX9asWbP05JNPysfHR3FxcUpNTdUdd9xxxTlHjBihuLg4ffrpp7r11ltL9IeEhFzy3AULFuiBBx4okRRJUq9evdSvXz/98ssvtmNt2rQxjXF3d1dBQcHFpwIAcNWq8lKaxbBn5zEqtaysLAUHB+uGYdPk7u3j6nCAclHr9a9dHQJQLgqMPG3M+j9lZmYqKKh89nAV/57o8cEAefo7dmVhfnae1nRaUK7xlocqVzECAACXV5WflUZiBAAATKryUlrl3BkFAABQDqgYAQAAk6pcMSIxAgAAJlU5MWIpDQAAoAgVIwAAYELFCAAAoIih3y/Zv9pmz00SExMTdcsttygwMFBhYWG6//77tX//ftOYtm3bymKxmNoTTzxhGnPkyBF169ZNfn5+CgsL0+jRo+2+CTIVIwAAYFLRFaPNmzdryJAhuuWWW1RQUKBnnnlGnTp10rfffmt6LNfjjz+uKVOm2F77+f3+UO7CwkJ169ZNERER2r59u9LT0/XYY4/J09NT06ZNK3MsJEYAAKDcZGVlmV57e3vL29vbdOz99983vU5OTlZYWJh2795tehSWn5+fIiIiSn2fDz74QN9++60+/PBDhYeHq2XLlnr++ec1duxYTZo0SV5eZbuTN0tpAADApLhi5GiTLjxsPTg42NYSExOv+P6ZmZmSpOrVq5uOL1myRDVq1FDTpk01fvx4/frrr7a+HTt2qFmzZgoPD7cdi4+PV1ZWlr755psyf3YqRgAAwMSZS2lHjx41PSvt4mpRifOsVg0fPlx33HGHmjZtajv+6KOPqk6dOoqKitLevXs1duxY7d+/X++8844kKSMjw5QUSbK9zsjIKHPcJEYAAKDcBAUF2fUQ2SFDhujrr7/Wtm3bTMf/9re/2f67WbNmioyM1D333KO0tDRdf/31TouXpTQAAGDizKU0ewwdOlQpKSnatGmTatWqddmxrVu3liQdPHhQkhQREaETJ06YxhS/vtS+pNKQGAEAABPDsDillf39DA0dOlSrVq3SRx99pHr16l3xnD179kiSIiMjJUlxcXH66quvdPLkSduYDRs2KCgoSI0bNy5zLCylAQAAlxoyZIiWLl2qNWvWKDAw0LYnKDg4WL6+vkpLS9PSpUvVtWtXhYaGau/evRoxYoTatGmj5s2bS5I6deqkxo0bq1+/fnrxxReVkZGhZ599VkOGDLnivqY/IjECAAAmxTdpdHSOspo3b56kCzdx/KOFCxeqf//+8vLy0ocffqiXX35Z2dnZio6OVq9evfTss8/axrq7uyslJUWDBw9WXFyc/P39lZCQYLrvUVmQGAEAAJOKvsGjYVz+PtnR0dHavHnzFeepU6eO3n333TK/b2nYYwQAAFCEihEAADCxd/P0peaojEiMAACASUUvpV1LSIwAAIBJVa4YsccIAACgCBUjAABgYjhhKa2yVoxIjAAAgIkh6QpX0JdpjsqIpTQAAIAiVIwAAICJVRZZKvDO19cSEiMAAGDCVWkAAACgYgQAAMyshkUWbvAIAABw4Yo0h69Kq6SXpbGUBgAAUISKEQAAMKnKm69JjAAAgAmJEQAAQJGqvPmaPUYAAABFqBgBAACTqnxVGokRAAAwuZAYObrHyEnBVDCW0gAAAIpQMQIAACZclQYAAFDEKGqOzlEZsZQGAABQhIoRAAAwYSkNAACgWBVeSyMxAgAAZk6oGKmSVozYYwQAAFCEihEAADDhztcAAABFqvLma5bSAAAAilAxAgAAZobF8c3TlbRiRGIEAABMqvIeI5bSAAAAilAxAgAAZtzgEQAA4IKqfFVamRKjtWvXlnnC++6776qDAQAAcKUyJUb3339/mSazWCwqLCx0JB4AAHAtqKRLYY4qU2JktVrLOw4AAHCNqMpLaQ5dlZaTk+OsOAAAwLXCcFKrhOxOjAoLC/X888+rZs2aCggI0KFDhyRJEyZMUFJSktMDBAAAqCh2J0ZTp05VcnKyXnzxRXl5edmON23aVP/973+dGhwAAHAFi5Na5WN3YrR48WK99tpr6tOnj9zd3W3HW7Rooe+++86pwQEAABdgKa3sjh07ppiYmBLHrVar8vPznRIUAACAK9idGDVu3Fhbt24tcXzlypW68cYbnRIUAABwoSpcMbL7ztcTJ05UQkKCjh07JqvVqnfeeUf79+/X4sWLlZKSUh4xAgCAimRYLjRH56iE7K4Y9ejRQ+vWrdOHH34of39/TZw4Ufv27dO6devUsWPH8ogRAACgQlzVs9LuuusubdiwwdmxAACAa4BhXGiOzlEZXfVDZHft2qV9+/ZJurDvqFWrVk4LCgAAuJAz9ghVlcTop59+0iOPPKKPP/5YISEhkqSzZ8/q9ttv1/Lly1WrVi1nxwgAAFAh7N5jNGjQIOXn52vfvn06ffq0Tp8+rX379slqtWrQoEHlESMAAKhIxZuvHW2VkN0Vo82bN2v79u1q2LCh7VjDhg01Z84c3XXXXU4NDgAAVDyLcaE5OkdlZHdiFB0dXeqNHAsLCxUVFeWUoAAAgAtV4T1Gdi+lzZgxQ8OGDdOuXbtsx3bt2qWnnnpKL730klODAwAAqEhlqhhVq1ZNFsvva4XZ2dlq3bq1PDwunF5QUCAPDw8NGDBA999/f7kECgAAKkgVvsFjmRKjl19+uZzDAAAA14wqvJRWpsQoISGhvOMAAABwObv3GP1RTk6OsrKyTA0AAFRyFfwQ2cTERN1yyy0KDAxUWFiY7r//fu3fv980JicnR0OGDFFoaKgCAgLUq1cvnThxwjTmyJEj6tatm/z8/BQWFqbRo0eroKDAro9ud2KUnZ2toUOHKiwsTP7+/qpWrZqpAQCASq6CE6PNmzdryJAh+uSTT7Rhwwbl5+erU6dOys7Oto0ZMWKE1q1bp7feekubN2/W8ePH1bNnT1t/YWGhunXrpry8PG3fvl2LFi1ScnKyJk6caNdHt/ty/TFjxmjTpk2aN2+e+vXrp7lz5+rYsWP6z3/+o+nTp9s7HQAA+BO7eDXJ29tb3t7epmPvv/++6XVycrLCwsK0e/dutWnTRpmZmUpKStLSpUvVvn17SdLChQvVqFEjffLJJ7rtttv0wQcf6Ntvv9WHH36o8PBwtWzZUs8//7zGjh2rSZMmycvLq0zx2l0xWrdunV599VX16tVLHh4euuuuu/Tss89q2rRpWrJkib3TAQCAa40T73wdHR2t4OBgW0tMTLzi22dmZkqSqlevLknavXu38vPz1aFDB9uYG264QbVr19aOHTskSTt27FCzZs0UHh5uGxMfH6+srCx98803Zf7odleMTp8+rfr160uSgoKCdPr0aUnSnXfeqcGDB9s7HQAAuMY4887XR48eVVBQkO34xdWii1mtVg0fPlx33HGHmjZtKknKyMiQl5eX7RmtxcLDw5WRkWEb88ekqLi/uK+s7K4Y1a9fX4cPH5Z0IVtbsWKFpAuVpIsDBgAAVVtQUJCpXSkxGjJkiL7++mstX768giI0szsx+utf/6ovv/xSkjRu3DjNnTtXPj4+GjFihEaPHu30AAEAQAWr4M3XxYYOHaqUlBRt2rRJtWrVsh2PiIhQXl6ezp49axp/4sQJRURE2MZcfJVa8eviMWVh91LaiBEjbP/doUMHfffdd9q9e7diYmLUvHlze6cDAABVnGEYGjZsmFatWqXU1FTVq1fP1N+qVSt5enpq48aN6tWrlyRp//79OnLkiOLi4iRJcXFxmjp1qk6ePKmwsDBJ0oYNGxQUFKTGjRuXORa7E6OL1alTR3Xq1HF0GgAAcI2wyAl7jOwYO2TIEC1dulRr1qxRYGCgbU9QcHCwfH19FRwcrIEDB+rpp59W9erVFRQUpGHDhikuLk633XabJKlTp05q3Lix+vXrpxdffFEZGRl69tlnNWTIkCsu3/1RmRKj2bNnl3nCf/zjH2UeCwAAMG/ePElS27ZtTccXLlyo/v37S5JmzZolNzc39erVS7m5uYqPj9err75qG+vu7q6UlBQNHjxYcXFx8vf3V0JCgqZMmWJXLBbDMK6YE15c0rrkZBaLDh06ZFcAqDhZWVkKDg5WW/WQh8XT1eEA5WL98T2uDgEoF1nnrKoWe0iZmZmmq7yc+h5FvyfqTJ8qNx8fh+ay5uTox3H/LNd4y0OZKkbFV6EBAIAqoAo/RNahZ6UBAAD8mTi8+RoAAPzJVOGKEYkRAAAwceadrysbltIAAACKUDECAABmVXgp7aoqRlu3blXfvn0VFxenY8eOSZLeeOMNbdu2zanBAQAAF3DRI0GuBXYnRm+//bbi4+Pl6+urL774Qrm5uZKkzMxMTZs2zekBAgAAVBS7E6N//etfmj9/vl5//XV5ev5+k8A77rhDn3/+uVODAwAAFa9487WjrTKye4/R/v371aZNmxLHg4ODSzz1FgAAVEKG5UJzdI5KyO6KUUREhA4ePFji+LZt21S/fn2nBAUAAFyIPUZl9/jjj+upp57Szp07ZbFYdPz4cS1ZskSjRo3S4MGDyyNGAACACmH3Utq4ceNktVp1zz336Ndff1WbNm3k7e2tUaNGadiwYeURIwAAqEBV+QaPdidGFotF//znPzV69GgdPHhQ58+fV+PGjRUQEFAe8QEAgIpWhe9jdNU3ePTy8lLjxo2dGQsAAIBL2Z0YtWvXThbLpXeaf/TRRw4FBAAAXMwZl9tXlYpRy5YtTa/z8/O1Z88eff3110pISHBWXAAAwFVYSiu7WbNmlXp80qRJOn/+vMMBAQAAuMpVPSutNH379tWCBQucNR0AAHCVKnwfo6vefH2xHTt2yMfHx1nTAQAAF+FyfTv07NnT9NowDKWnp2vXrl2aMGGC0wIDAACoaHYnRsHBwabXbm5uatiwoaZMmaJOnTo5LTAAAICKZldiVFhYqL/+9a9q1qyZqlWrVl4xAQAAV6rCV6XZtfna3d1dnTp10tmzZ8spHAAA4GrFe4wcbZWR3VelNW3aVIcOHSqPWAAAAFzK7sToX//6l0aNGqWUlBSlp6crKyvL1AAAwJ9AFbxUX7Jjj9GUKVM0cuRIde3aVZJ03333mR4NYhiGLBaLCgsLnR8lAACoOFV4j1GZE6PJkyfriSee0KZNm8ozHgAAAJcpc2JkGBdSv7vvvrvcggEAAK7HDR7L6I9LZwAA4E+KpbSyiY2NvWJydPr0aYcCAgAAcBW7EqPJkyeXuPM1AAD4c2EprYx69+6tsLCw8ooFAABcC6rwUlqZ72PE/iIAAPBnZ/dVaQAA4E+uCleMypwYWa3W8owDAABcI9hjBAAAUKwKV4zsflYaAADAnxUVIwAAYFaFK0YkRgAAwKQq7zFiKQ0AAKAIFSMAAGDGUhoAAMAFLKUBAACAihEAALgIS2kAAABFqnBixFIaAABAESpGAADAxFLUHJ2jMiIxAgAAZlV4KY3ECAAAmHC5PgAAAKgYAQCAi7CUBgAA8AeVNLFxFEtpAAAARagYAQAAk6q8+ZrECAAAmFXhPUYspQEAAJfbsmWL7r33XkVFRclisWj16tWm/v79+8tisZha586dTWNOnz6tPn36KCgoSCEhIRo4cKDOnz9vVxwkRgAAwKR4Kc3RZo/s7Gy1aNFCc+fOveSYzp07Kz093daWLVtm6u/Tp4+++eYbbdiwQSkpKdqyZYv+9re/2RUHS2kAAMDMBUtpXbp0UZcuXS47xtvbWxEREaX27du3T++//74+++wz3XzzzZKkOXPmqGvXrnrppZcUFRVVpjioGAEAgHKTlZVlarm5uVc9V2pqqsLCwtSwYUMNHjxYp06dsvXt2LFDISEhtqRIkjp06CA3Nzft3LmzzO9BYgQAAEycuZQWHR2t4OBgW0tMTLyqmDp37qzFixdr48aNeuGFF7R582Z16dJFhYWFkqSMjAyFhYWZzvHw8FD16tWVkZFR5vdhKQ0AAJg5cSnt6NGjCgoKsh329va+qul69+5t++9mzZqpefPmuv7665Wamqp77rnHoVD/iIoRAAAwM5zUJAUFBZna1SZGF6tfv75q1KihgwcPSpIiIiJ08uRJ05iCggKdPn36kvuSSkNiBAAAKp2ffvpJp06dUmRkpCQpLi5OZ8+e1e7du21jPvroI1mtVrVu3brM87KUBgAATFxx5+vz58/bqj+SdPjwYe3Zs0fVq1dX9erVNXnyZPXq1UsRERFKS0vTmDFjFBMTo/j4eElSo0aN1LlzZz3++OOaP3++8vPzNXToUPXu3bvMV6RJVIwAAMDFnLiUVla7du3SjTfeqBtvvFGS9PTTT+vGG2/UxIkT5e7urr179+q+++5TbGysBg4cqFatWmnr1q2mpbklS5bohhtu0D333KOuXbvqzjvv1GuvvWZXHFSMAACAy7Vt21aGcelsav369Veco3r16lq6dKlDcZAYAQAAE4thyHKZJKWsc1RGJEYAAMCMh8gCAACAihEAADBxxVVp1woSIwAAYMZSGgAAAKgYAQAAE5bSAAAAilXhpTQSIwAAYFKVK0bsMQIAAChCxQgAAJixlAYAAPC7yroU5iiW0gAAAIpQMQIAAGaGcaE5OkclRGIEAABMuCoNAAAAVIwAAMBFuCoNAADgAov1QnN0jsqIpTQAAIAiVIwAB/QdmaF+I0+Yjh096K1BbW6QJEXWydXjE4+rya3Z8vQytHtToOY+W1Nnf/F0RbjAFa1bFKr/La6hE0e9JEl1Guaoz4gM3dL+nCTplTG19MXWQJ064SlfP6sa3Zytgf88rtoNcm1zvPpsTX3zmb9+3O+j6Jhczftwv0s+CxzAUhqAq/XDdz4a93B92+vCQoskydu3UNOWHdKhb3019sHrJUkJYzI0ZdFhPdW9gQzD4pJ4gcu5LjJfA545rpr1cmUYFm14q5om/bWe5n5wQHUb5qhB89/UvucZXVczX+fOuOv/ZkbomUeu16Kd38rd/fd54nuf1ndf+Onwt76u+zC4alyV5iL9+/eXxWKRxWKRl5eXYmJiNGXKFBUUFCg1NVUWi0VNmjRRYWGh6byQkBAlJyfbXtetW9c2zx/b9OnTJck219mzZ0vEULduXb388su218XnfvLJJ6Zxubm5Cg0NlcViUWpqqqkvJSVFd999twIDA+Xn56dbbrnFFJ8k/fDDD7JYLAoLC9O5c+dMfS1bttSkSZNsr9u2bavhw4eXiHXZsmVyd3fXkCFDSvTBdQoLpTM/e9pa1ukLf280ufVXhUfnaebwaP3wna9++M5XM56qrQYtflPLO8+7OGqgdLd1ytKt95xTzfp5qnV9rv46LkM+/lZ9t9tPktS17yk1uy1bEdF5atD8NyWMTdfPx71sFSZJevJfx3TfX39RZO08V30MOKr4PkaOtkrI5XuMOnfurPT0dH3//fcaOXKkJk2apBkzZtj6Dx06pMWLF19xnilTpig9Pd3Uhg0bdlUxRUdHa+HChaZjq1atUkBAQImxc+bMUY8ePXTHHXdo586d2rt3r3r37q0nnnhCo0aNKjH+3Llzeumll64qrqSkJI0ZM0bLli1TTk7OVc0B56tZL09LP/9GyTv2aez/+1HX1bzwy8DTyyoZUn7e75Wh/FyLDKvU5NZsV4ULlFlhoZS6OkS5v7qp0c0lv2ZzfnXTB29WV0TtXF0Xle+CCAHnc3li5O3trYiICNWpU0eDBw9Whw4dtHbtWlv/sGHD9Nxzzyk3N/cys0iBgYGKiIgwNX9//6uKKSEhQcuXL9dvv/1mO7ZgwQIlJCSYxh09elQjR47U8OHDNW3aNDVu3FgxMTEaOXKkZsyYoZkzZ2rnzp2mc4YNG6Z///vfOnnypF0xHT58WNu3b9e4ceMUGxurd95554rn5ObmKisry9TgXN997qeXhkfrn33qa864moqonaeZqw7K179Q3+32V86vbhr4z3R5+1rl7Vuoxycel7uHVD2MXyK4dh3e56MeMc3UvW4LzR4XrYlJh1Un9vefweuSQ9Ujppl6xDTXZx8FKXF5mjy9Kmd1AKUrXkpztFVGLk+MLubr66u8vN/Lr8OHD1dBQYHmzJlTYTG0atVKdevW1dtvvy1JOnLkiLZs2aJ+/fqZxq1cuVL5+fmlVob+/ve/KyAgQMuWLTMdf+SRR2xLhvZYuHChunXrpuDgYPXt21dJSUlXPCcxMVHBwcG2Fh0dbdd74sp2bQrS1pQQHd7nq92bg/Rs3/oKCCpUm/vOKvO0h/7197pq3TFLq7//Sqv2fy3/IKu+3+srw8r+Ily7al2fq1c37Nfs/x1Q98d+0UtP1dGPB7xt/e17ntGrH+zXS+98r1r1czX173WVl8PX9J+K4aRWCV0ziZFhGPrwww+1fv16tW/f3nbcz89Pzz33nBITE5WZmXnJ88eOHauAgABT27p161XHM2DAAC1YsECSlJycrK5du+q6664zjTlw4ICCg4MVGRlZ4nwvLy/Vr19fBw4cMB0v3vv02muvKS0trUyxWK1WJScnq2/fvpKk3r17a9u2bTp8+PBlzxs/frwyMzNt7ejRo2V6P1y97Cx3/XTIW1F1LyT3n28O1F9vb6SHmzfRg02basY/ais0Il/pR7yuMBPgOp5ehmrWu7CHaMAz6arX+Det/u/vP//8g6yqWT9PzW7L1rOv/6CjB7318XvBLowYcB6XJ0YpKSkKCAiQj4+PunTpoocffti0EVmSBg4cqNDQUL3wwguXnGf06NHas2ePqd18881XHVffvn21Y8cOHTp0SMnJyRowYMBVz3Wx+Ph43XnnnZowYUKZxm/YsEHZ2dnq2rWrJKlGjRrq2LGjLXG7FG9vbwUFBZkaypePX6Gi6uTp9EnzBZ9Zpz2UneWuFnecU0iNAn3yAf9foPIwDCk/r/RfF4YhybBcsh+VU1VeSnP55frt2rXTvHnz5OXlpaioKHl4lAzJw8NDU6dOVf/+/TV06NBS56lRo4ZiYmJK7StOCDIzMxUSEmLqO3v2rIKDS/6lExoaqu7du2vgwIHKyclRly5dSlxNFhsbq8zMTB0/flxRUVGmvry8PKWlpaldu3alxjR9+nTFxcVp9OjRpfb/UVJSkk6fPi1f398ve7Vardq7d68mT54sNzd+ILnK4xOP65MPgnTyJy+FRuSr36gMFVql1FXVJEmdHj6tI997K/OUhxq1+lWDpxzTqteu009pPi6OHCjdgmmRuqV9lq6rma/fzrtp06pq2rs9QFOXpin9Ry9tXhuiVnefU3D1Av2c7qkV/y9cXr5W3XrP73sYjx32Uk62u07/7KG8HIvSvr7ws6t2bA57kSoLZ1xVVkmvSnN5YuTv73/JhOaPHnzwQc2YMUOTJ0+2+z0aNGggNzc37d69W3Xq1LEdP3TokDIzMxUbG1vqeQMGDFDXrl01duxYuf/xBh1FevXqpbFjx2rmzJmaOXOmqW/+/PnKzs7WI488Uurct956q3r27Klx48ZdNvZTp05pzZo1Wr58uZo0aWI7XlhYqDvvvFMffPCBOnfufNk5UH5qROZr/Ks/KrBaoTJPeeibz/w1vHsDZRZdsl/r+hz9dXy6AkMKdeKop5bNDtc7r9VwcdTApZ39xUMz/lFHp096yC+wUPUa5Wjq0jS1uvu8TmV46OudAVr1+nU6n+mukBoFanbbec1a871CahTY5nh5VG3t3fH7VbxPdmooSVq081tFRHMJP65tLk+M7DF9+nTFx8eX2nfu3DllZGSYjvn5+SkoKEiBgYEaNGiQRo4cKQ8PDzVr1kxHjx7V2LFjddttt+n2228vdc7OnTvr559/vuQSVO3atfXiiy9q5MiR8vHxUb9+/eTp6ak1a9bomWee0ciRI9W6detLfp6pU6eqSZMmpVbJir3xxhsKDQ3VQw89JIvFvLmxa9euSkpKIjFyocTBdS7bv2BalBZMi7rsGOBa8vS/L70XMTSiQP/6v0NXnGPG2wedGRJcgBs8VhLt27dX+/btVVBQUKJv4sSJioyMNLUxY8bY+l955RUlJCRo7NixatKkifr376/mzZtr3bp1JRKOYhaLRTVq1JCX16U3yg4fPlyrVq3S1q1bdfPNN6tp06ZaunSp5s2bd8X7FcXGxmrAgAGXvSfRggUL9MADD5QaY69evbR27Vr98ssvl30fAADsUoWvSrMYRiVdBITdsrKyFBwcrLbqIQ8Lz+rCn9P643tcHQJQLrLOWVUt9sIWkPK6mKb490Rc5yny8HRsL2RBfo52vD+xXOMtD5VqKQ0AAJS/qryURmIEAADMrMaF5ugclRCJEQAAMHPGHqHKmRdVrs3XAAAA5YmKEQAAMLHICXuMnBJJxSMxAgAAZlX4ztcspQEAABShYgQAAEy4XB8AAKAYV6UBAACAihEAADCxGIYsDm6edvR8VyExAgAAZtai5ugclRBLaQAAAEWoGAEAABOW0gAAAIpV4avSSIwAAIAZd74GAAAAFSMAAGDCna8BAACKsZQGAAAAKkYAAMDEYr3QHJ2jMiIxAgAAZiylAQAAgIoRAAAw4waPAAAAF1TlR4KwlAYAAFxuy5YtuvfeexUVFSWLxaLVq1eb+g3D0MSJExUZGSlfX1916NBB33//vWnM6dOn1adPHwUFBSkkJEQDBw7U+fPn7YqDxAgAAJgVb752tNkhOztbLVq00Ny5c0vtf/HFFzV79mzNnz9fO3fulL+/v+Lj45WTk2Mb06dPH33zzTfasGGDUlJStGXLFv3tb3+zKw6W0gAAgJkhydHL7e1cSevSpYu6dOlS+lSGoZdfflnPPvusevToIUlavHixwsPDtXr1avXu3Vv79u3T+++/r88++0w333yzJGnOnDnq2rWrXnrpJUVFRZUpDipGAADApHiPkaNNkrKyskwtNzfX7ngOHz6sjIwMdejQwXYsODhYrVu31o4dOyRJO3bsUEhIiC0pkqQOHTrIzc1NO3fuLPN7kRgBAIByEx0dreDgYFtLTEy0e46MjAxJUnh4uOl4eHi4rS8jI0NhYWGmfg8PD1WvXt02pixYSgMAAGaGnHCDxwv/c/ToUQUFBdkOe3t7OzZvOaNiBAAAzJy4+TooKMjUriYxioiIkCSdOHHCdPzEiRO2voiICJ08edLUX1BQoNOnT9vGlAWJEQAAuKbVq1dPERER2rhxo+1YVlaWdu7cqbi4OElSXFyczp49q927d9vGfPTRR7JarWrdunWZ34ulNAAAYGaVZHHCHHY4f/68Dh48aHt9+PBh7dmzR9WrV1ft2rU1fPhw/etf/1KDBg1Ur149TZgwQVFRUbr//vslSY0aNVLnzp31+OOPa/78+crPz9fQoUPVu3fvMl+RJpEYAQCAi7jizte7du1Su3btbK+ffvppSVJCQoKSk5M1ZswYZWdn629/+5vOnj2rO++8U++//758fHxs5yxZskRDhw7VPffcIzc3N/Xq1UuzZ8+2N+5Kes9u2C0rK0vBwcFqqx7ysHi6OhygXKw/vsfVIQDlIuucVdViDykzM9O0mdmp71H0e+KepmPk4e7YJumCwlxt/PrFco23PFAxAgAAZldx5+pS56iESIwAAIBZFU6MuCoNAACgCBUjAABgVoUrRiRGAADAzAWX618rSIwAAICJKy7Xv1awxwgAAKAIFSMAAGDGHiMAAIAiVkOyOJjYWCtnYsRSGgAAQBEqRgAAwIylNAAAgGJOSIxUORMjltIAAACKUDECAABmLKUBAAAUsRpyeCmMq9IAAAAqNypGAADAzLBeaI7OUQmRGAEAADP2GAEAABRhjxEAAACoGAEAADOW0gAAAIoYckJi5JRIKhxLaQAAAEWoGAEAADOW0gAAAIpYrZIcvA+RtXLex4ilNAAAgCJUjAAAgBlLaQAAAEWqcGLEUhoAAEARKkYAAMCsCj8ShMQIAACYGIZVhuHYVWWOnu8qJEYAAMDMMByv+LDHCAAAoHKjYgQAAMwMJ+wxqqQVIxIjAABgZrVKFgf3CFXSPUYspQEAABShYgQAAMxYSgMAALjAsFplOLiUVlkv12cpDQAAoAgVIwAAYMZSGgAAQBGrIVmqZmLEUhoAAEARKkYAAMDMMCQ5eh+jylkxIjECAAAmhtWQ4eBSmkFiBAAA/hQMqxyvGHG5PgAAQKVGxQgAAJiwlAYAAFCsCi+lkRhVIcXZe4HyHb5vF3CtyjpXOX8YA1eSdf7C13ZFVGKc8XuiQPnOCaaCkRhVIefOnZMkbdO7Lo4EKD/VYl0dAVC+zp07p+Dg4HKZ28vLSxEREdqW4ZzfExEREfLy8nLKXBXFYlTWRUDYzWq16vjx4woMDJTFYnF1OH96WVlZio6O1tGjRxUUFOTqcACn42u8YhmGoXPnzikqKkpubuV37VROTo7y8vKcMpeXl5d8fHycMldFoWJUhbi5ualWrVquDqPKCQoK4pcG/tT4Gq845VUp+iMfH59Kl8w4E5frAwAAFCExAgAAKEJiBJQTb29vPffcc/L29nZ1KEC54Gscf0ZsvgYAAChCxQgAAKAIiREAAEAREiMAAIAiJEYAAABFSIxQZfTv318Wi0XTp083HV+9erXpTuCFhYWaNWuWmjVrJh8fH1WrVk1dunTRxx9/bDovOTlZFotFFotFbm5uioyM1MMPP6wjR46YxrVt27bU95Wkbt26yWKxaNKkSSX6li1bJnd3dw0ZMqREX2pqqiwWi86ePWvHvwAqm+KvWYvFIi8vL8XExGjKlCkqKCiwfQ00adJEhYWFpvNCQkKUnJxse123bl3bPH9sxV+Tl/t6qlu3rl5++WXb6+JzP/nkE9O43NxchYaGymKxKDU11dSXkpKiu+++W4GBgfLz89Mtt9xiik+SfvjhB1ksFoWFhdkeX1SsZcuWpu+Rtm3bavjw4SVivdz3DFBWJEaoUnx8fPTCCy/ozJkzpfYbhqHevXtrypQpeuqpp7Rv3z6lpqYqOjpabdu21erVq03jg4KClJ6ermPHjuntt9/W/v379eCDD5aYNzo6usQvgmPHjmnjxo2KjIwsNZakpCSNGTNGy5YtU05OzlV9XlR+nTt3Vnp6ur7//nuNHDlSkyZN0owZM2z9hw4d0uLFi684z5QpU5Senm5qw4YNu6qYoqOjtXDhQtOxVatWKSAgoMTYOXPmqEePHrrjjju0c+dO7d27V71799YTTzyhUaNGlRh/7tw5vfTSS1cVF98zcAYSI1QpHTp0UEREhBITE0vtX7FihVauXKnFixdr0KBBqlevnlq0aKHXXntN9913nwYNGqTs7GzbeIvFooiICEVGRur222/XwIED9emnnyorK8s0b/fu3fXLL7+Yqk6LFi1Sp06dFBYWViKOw4cPa/v27Ro3bpxiY2P1zjvvOOlfAJWNt7e3IiIiVKdOHQ0ePFgdOnTQ2rVrbf3Dhg3Tc889p9zc3MvOExgYqIiICFPz9/e/qpgSEhK0fPly/fbbb7ZjCxYsUEJCgmnc0aNHNXLkSA0fPlzTpk1T48aNFRMTo5EjR2rGjBmaOXOmdu7caTpn2LBh+ve//62TJ0/aFRPfM3AWEiNUKe7u7po2bZrmzJmjn376qUT/0qVLFRsbq3vvvbdE38iRI3Xq1Clt2LCh1LlPnjypVatWyd3dXe7u7qY+Ly8v9enTx/RXdnJysgYMGFDqXAsXLlS3bt0UHBysvn37KikpyZ6PiT8xX19f0wM+hw8froKCAs2ZM6fCYmjVqpXq1q2rt99+W5J05MgRbdmyRf369TONW7lypfLz80utDP39739XQECAli1bZjr+yCOP2JYM7cH3DJyFxAhVzgMPPKCWLVvqueeeK9F34MABNWrUqNTzio8fOHDAdiwzM1MBAQHy9/dXeHi4Nm3apCFDhpT6l/iAAQO0YsUKZWdna8uWLcrMzFT37t1LjLNarUpOTlbfvn0lSb1799a2bdt0+PDhq/q8+HMwDEMffvih1q9fr/bt29uO+/n56bnnnlNiYqIyMzMvef7YsWMVEBBgalu3br3qeAYMGKAFCxZIupDkd+3aVdddd51pzIEDBxQcHFzqcrGXl5fq169v+n6SZNv79NprryktLa1MsfA9A2ciMUKV9MILL2jRokXat29fiT57bgYfGBioPXv2aNeuXZo5c6ZuuukmTZ06tdSxLVq0UIMGDbRy5UotWLBA/fr1k4eHR4lxGzZsUHZ2trp27SpJqlGjhjp27Gj7JYSqJSUlRQEBAfLx8VGXLl308MMPl9isP3DgQIWGhuqFF1645DyjR4/Wnj17TO3mm2++6rj69u2rHTt26NChQ5etfl6N+Ph43XnnnZowYUKZxvM9A2cq+VMZqALatGmj+Ph4jR8/Xv3797cdj42NLTVZkmQ7Hhsbazvm5uammJgYSRcqSmlpaRo8eLDeeOONUucYMGCA5s6dq2+//VaffvppqWOSkpJ0+vRp+fr62o5ZrVbt3btXkydPlpsbf89UJe3atdO8efPk5eWlqKioUpNpDw8PTZ06Vf3799fQoUNLnadGjRq2r9WLBQUFSbpQAQ0JCTH1nT17VsHBwSXOCQ0NVffu3TVw4EDl5OSoS5cuJa4mi42NVWZmpo4fP66oqChTX15entLS0tSuXbtSY5o+fbri4uI0evToUvv/iO8ZOBNfLaiypk+frnXr1mnHjh22Y71799b333+vdevWlRg/c+ZMhYaGqmPHjpecc9y4cXrzzTf1+eefl9r/6KOP6quvvlLTpk3VuHHjEv2nTp3SmjVrtHz5ctNf9l988YXOnDmjDz744Co+KSozf39/xcTEqHbt2qUmRcUefPBBNWnSRJMnT7b7PRo0aCA3Nzft3r3bdPzQoUPKzMw0/THwRwMGDFBqaqoee+yxEvvqJKlXr17y9PTUzJkzS/TNnz9f2dnZeuSRR0qd+9Zbb1XPnj01bty4y8bO9wycjYoRqqxmzZqpT58+mj17tu1Y79699dZbbykhIUEzZszQPffco6ysLM2dO1dr167VW2+9ddkreaKjo/XAAw9o4sSJSklJKdFfrVo1paeny9PTs9Tz33jjDYWGhuqhhx4y3VtJkrp27aqkpCR17tzZduyrr75SYGCg7bXFYlGLFi3K/G+AP5fp06crPj6+1L5z584pIyPDdMzPz09BQUEKDAzUoEGDNHLkSHl4eKhZs2Y6evSoxo4dq9tuu0233357qXN27txZP//8s63idLHatWvrxRdf1MiRI+Xj46N+/frJ09NTa9as0TPPPKORI0eqdevWl/w8U6dOVZMmTS6bENr7PQNcCRUjVGlTpkyR1Wq1vbZYLFqxYoWeeeYZzZo1Sw0bNtRdd92lH3/8Uampqbr//vuvOOeIESP0v//975JLZSEhIZdMrhYsWKAHHnigxA946cJf32vXrtUvv/xiO9amTRvdeOONttaqVasrxoc/r/bt26t9+/YqKCgo0Tdx4kRFRkaa2pgxY2z9r7zyihISEjR27Fg1adJE/fv3V/PmzbVu3bpSvx6lC98vNWrUkJeX1yVjGj58uFatWqWtW7fq5ptvVtOmTbV06VLNmzfvivcrio2N1YABAy57TyJ7v2eAK7EY9uw0BQAA+BOjYgQAAFCExAgAAKAIiREAAEAREiMAAIAiJEYAAABFSIwAAACKkBgBAAAUITECAAAoQmIEoEL179/fdAfxtm3bavjw4RUeR2pqqiwWi86ePXvJMRaLRatXry7znJMmTVLLli0diuuHH36QxWLRnj17HJoHwNUhMQKg/v37y2KxyGKxyMvLSzExMZoyZUqpj5ZwtnfeeUfPP/98mcaWJZkBAEfwEFkAki48EHThwoXKzc3Vu+++qyFDhsjT01Pjx48vMTYvL++yz8eyR/Xq1Z0yDwA4AxUjAJIkb29vRUREqE6dOho8eLA6dOigtWvXSvp9+Wvq1KmKiopSw4YNJUlHjx7VQw89pJCQEFWvXl09evTQDz/8YJuzsLBQTz/9tEJCQhQaGqoxY8bo4sczXryUlpubq7Fjxyo6Olre3t6KiYlRUlKSfvjhB7Vr106SVK1aNVksFvXv31+SZLValZiYqHr16snX11ctWrTQypUrTe/z7rvvKjY2Vr6+vmrXrp0pzrIaO3asYmNj5efnp/r162vChAnKz88vMe4///mPoqOj5efnp4ceekiZmZmm/v/+979q1KiRfHx8dMMNN+jVV1+1OxYA5YPECECpfH19lZeXZ3u9ceNG7d+/Xxs2bFBKSory8/MVHx+vwMBAbd26VR9//LECAgLUuXNn23kzZ85UcnKyFixYoG3btun06dNatWrVZd/3scce07JlyzR79mzt27dP//nPfxQQEKDo6Gi9/fbbkqT9+/crPT1dr7zyiiQpMTFRixcv1vz58/XNN99oxIgR6tu3rzZv3izpQgLXs2dP3XvvvdqzZ48GDRqkcePG2f1vEhgYqOTkZH377bd65ZVX9Prrr2vWrFmmMQcPHtSKFSu0bt06vf/++/riiy/05JNP2vqXLFmiiRMnaurUqdq3b5+mTZumCRMmaNGiRXbHA6AcGACqvISEBKNHjx6GYRiG1Wo1NmzYYHh7exujRo2y9YeHhxu5ubm2c9544w2jYcOGhtVqtR3Lzc01fH19jfXr1xuGYRiRkZHGiy++aOvPz883atWqZXsvwzCMu+++23jqqacMwzCM/fv3G5KMDRs2lBrnpk2bDEnGmTNnbMdycnIMPz8/Y/v27aaxAwcONB555BHDMAxj/PjxRuPGjU39Y8eOLTHXxSQZq1atumT/jBkzjFatWtleP/fcc4a7u7vx008/2Y699957hpubm5Genm4YhmFcf/31xtKlS03zPP/880ZcXJxhGIZx+PBhQ5LxxRdfXPJ9AZQf9hgBkCSlpKQoICBA+fn5slqtevTRRzVp0iRbf7NmzUz7ir788ksdPHhQgYGBpnlycnKUlpamzMxMpaenq3Xr1rY+Dw8P3XzzzSWW04rt2bNH7u7uuvvuu8sc98GDB/Xrr7+qY8eOpuN5eXm68cYbJUn79u0zxSFJcXFxZX6PYm+++aZmz56ttLQ0nT9/XgUFBQoKCjKNqV27tmrWrGl6H6vVqv379yswMFBpaWkaOHCgHn/8cduYgoICBQcH2x0PAOcjMQIgSWrXrp3mzZsnLy8vRUVFycPD/OPB39/f9Pr8+fNq1aqVlixZUmKu66677qpi8PX1tfuc8+fPS5L+97//mRIS6cK+KWfZsWOH+vTpo8mTJys+Pl7BwcFavny5Zs6caXesr7/+eolEzd3d3WmxArh6JEYAJF1IfGJiYso8/qabbtKbb76psLCwElWTYpGRkdq5c6fatGkj6UJlZPfu3brppptKHd+sWTNZrVZt3rxZHTp0KNFfXLEqLCy0HWvcuLG8vb115MiRS1aaGjVqZNtIXuyTTz658of8g+3bt6tOnTr65z//aTv2448/lhh35MgRHT9+XFFRUbb3cXNzU8OGDRUeHq6oqCgdOnRIffr0sev9AVQMNl8DuCp9+vRRjRo11KNHD23dulWHDx9Wamqq/vGPf+inn36SJD311FOaPn26Vq9ere+++05PPvnkZe9BVLduXSUkJGjAgAFavXq1bc4VK1ZIkurUqSOLxaKUlBT9/PPPOn/+vAIDAzVq1CiNGDFCixYtUlpamj7//HPNmTPHtqH5iSee0Pfff6/Ro0dr//79Wrp0qZKTk+36vA0aNNCRI0e0fPlypaWlafbs2aVuJPfx8VFCQoK+/PJLbd26Vf/4xz/00EMPKSIiQpI0efJkJSYmavbs2Tpw4IC++uorLVy4UP/+97/tigdA+SAxAnBV/Pz8tGXLFtWuXVs9e/ZUo0aNNHDgQOXk5NgqSCNHjlS/fv2UkJCguLg4BQYG6oEHHrjsvPPmzdNf/vIXPfnkk7rhhhv0+OOPKzs7W5JUs2ZNTZ48WePGjVN4eLiGDh0qSXr++ec1YcIEJSYmqlGjRurcubP+97//qV69epIu7Pt5++23tXr1arVo0ULz58/XtGnT7Pq89913n0aMGKGhQ4eqZcuW2r59uyZMmFBiXExMjHr27KmuXbuqU6dOat68uely/EGDBum///2vFi5cqGbNmunuu+9WcnKyLVYArmUxLrULEgAAoIqhYgQAAFCExAgAAKAIiREAAEAREiMAAIAiJEYAAABFSIwAAACKkBgBAAAUITECAAAoQmIEAABQhMQIAACgCIkRAABAkf8Pe4vJBtyHizcAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "from sklearn.metrics import ConfusionMatrixDisplay\n",
+        "\n",
+        "ConfusionMatrixDisplay(cm, display_labels=labels).plot();"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "twYkoOqffahY"
+      },
+      "source": [
+        "## Areas for Improvement\n",
+        "Our dataset is imbalanced, with more pneumonia cases than normal. This can make it harder for the model to learn to recognize the less common class.  While getting more data is always ideal but not feasible for this demonstration, here are some strategies to try:\n",
+        "\n",
+        "**Potential Solutions**\n",
+        "\n",
+        "* **Oversampling the Minority Class:**  Increase the number of normal cases in the training set. Care must be taken to ensure that the training and validation splits are done in a way that prevents data leakage.\n",
+        "\n",
+        "* **Explore More Complex Architectures:** If you have the computational resources, try a more powerful model architecture like a Vision Transformer (ViT). Their attention mechanisms might help them learn more complex patterns.\n",
+        "\n",
+        "* **Transfer Learning:** Train the model on a large, pre-trained image classification model like a ResNet or VGG. This can leverage the knowledge learned from a broader dataset and potentially improve performance, especially with limited data.\n",
+        "\n",
+        "* **Ensemble Methods:** Combine the predictions of multiple models. This often gives better results than a single model, but can make your system more complex."
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.10.12"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "2b64ca6bcf4c4c79a655289f69364a44": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_20d886f418bc4b70ab2734c5790cbc16",
+              "IPY_MODEL_848d5b4533d646f58ff5153b7e5a9f01",
+              "IPY_MODEL_bfe19b42bcdd40a487373d05d4161000"
+            ],
+            "layout": "IPY_MODEL_0c078a29235845569c7a51f03d5a11fc"
+          }
+        },
+        "20d886f418bc4b70ab2734c5790cbc16": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2baa86f302b140ea8c42df4665a39c24",
+            "placeholder": "​",
+            "style": "IPY_MODEL_75b888579f4142d6985d80c21f69e874",
+            "value": "Epoch 1/5: 100%"
+          }
+        },
+        "848d5b4533d646f58ff5153b7e5a9f01": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f208f20a7d0c4043be84d2cd3ef137b3",
+            "max": 164,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_45d41d08d03c40f4878b2040c8beb834",
+            "value": 164
+          }
+        },
+        "bfe19b42bcdd40a487373d05d4161000": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_77f04b28b3564c9a9fe7afd2b47b4432",
+            "placeholder": "​",
+            "style": "IPY_MODEL_bb3af45c886f48a9a1d64d31f50f047e",
+            "value": " 164/164 [09:46&lt;00:00,  1.32it/s, train_acc=0.737, train_loss=3.84, val_acc=0.888, val_loss=2.11]"
+          }
+        },
+        "0c078a29235845569c7a51f03d5a11fc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2baa86f302b140ea8c42df4665a39c24": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "75b888579f4142d6985d80c21f69e874": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f208f20a7d0c4043be84d2cd3ef137b3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "45d41d08d03c40f4878b2040c8beb834": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "77f04b28b3564c9a9fe7afd2b47b4432": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bb3af45c886f48a9a1d64d31f50f047e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "4cfcc1ebe10047798453c86a8d267336": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_33181f1f28ba42498ae9f8b0b9895d47",
+              "IPY_MODEL_6cebd409464448fca32bb0c84aa11237",
+              "IPY_MODEL_19d51182bf354bd2a1ec01c390e69bd1"
+            ],
+            "layout": "IPY_MODEL_a9588f5a68bb445998893f0b81f9bd6c"
+          }
+        },
+        "33181f1f28ba42498ae9f8b0b9895d47": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_507e3879969c40b88537146c8add6877",
+            "placeholder": "​",
+            "style": "IPY_MODEL_6310ee08bba44547b4e843de6a6333f2",
+            "value": "Epoch 2/5: 100%"
+          }
+        },
+        "6cebd409464448fca32bb0c84aa11237": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_edea008acaff491c99dff03b5aa96a20",
+            "max": 164,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_ade2d223dad445e6a30e943e25309b5a",
+            "value": 164
+          }
+        },
+        "19d51182bf354bd2a1ec01c390e69bd1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d29f716fe5934c64bf609203d2628839",
+            "placeholder": "​",
+            "style": "IPY_MODEL_067537d80e204586bd88f69a72e287f5",
+            "value": " 164/164 [08:59&lt;00:00,  1.33it/s, train_acc=0.884, train_loss=2.47, val_acc=0.898, val_loss=1.71]"
+          }
+        },
+        "a9588f5a68bb445998893f0b81f9bd6c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "507e3879969c40b88537146c8add6877": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6310ee08bba44547b4e843de6a6333f2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "edea008acaff491c99dff03b5aa96a20": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ade2d223dad445e6a30e943e25309b5a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "d29f716fe5934c64bf609203d2628839": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "067537d80e204586bd88f69a72e287f5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d20542e0f64845ce8224eb9da7c984b1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_24074a47196e48189381e5482e644bd1",
+              "IPY_MODEL_0989e92e4b0648bebfea0c77a27159f4",
+              "IPY_MODEL_90e9fa8000a348c1b767e1a1d9ee2a4c"
+            ],
+            "layout": "IPY_MODEL_78b75313c22f4a788f0b3c1002a42b08"
+          }
+        },
+        "24074a47196e48189381e5482e644bd1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3c0ecd26f61144d1b581da6423244610",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9996833482a34d979878b171f232b306",
+            "value": "Epoch 3/5: 100%"
+          }
+        },
+        "0989e92e4b0648bebfea0c77a27159f4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_58d08253ad4741afa294cb476597b450",
+            "max": 164,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_fd55ef7b5f2646eea3c9eb9123e2cce2",
+            "value": 164
+          }
+        },
+        "90e9fa8000a348c1b767e1a1d9ee2a4c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a1b13e2a1a8f4430b1064a3e96758461",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e91ea0854d9047aba2f4f6767f84dbca",
+            "value": " 164/164 [07:48&lt;00:00,  1.33it/s, train_acc=0.91, train_loss=1.94, val_acc=0.925, val_loss=1.35]"
+          }
+        },
+        "78b75313c22f4a788f0b3c1002a42b08": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3c0ecd26f61144d1b581da6423244610": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9996833482a34d979878b171f232b306": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "58d08253ad4741afa294cb476597b450": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "fd55ef7b5f2646eea3c9eb9123e2cce2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "a1b13e2a1a8f4430b1064a3e96758461": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e91ea0854d9047aba2f4f6767f84dbca": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "174e32b6c33246f88ed28079a9b85a9f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_5b453cbe2d5b4a458ff0b0b01a1dbfbd",
+              "IPY_MODEL_9f89553ec0ac4cb09446e7f3042ae54b",
+              "IPY_MODEL_124f6de22f1c4b68bf3db51add98ccae"
+            ],
+            "layout": "IPY_MODEL_af7a51cd749b4381ad9b2f93f3575303"
+          }
+        },
+        "5b453cbe2d5b4a458ff0b0b01a1dbfbd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bce21439b7f34c9eb0c7bb819c3b456c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b8f86628fe8946edba6c18b77129f5cc",
+            "value": "Epoch 4/5: 100%"
+          }
+        },
+        "9f89553ec0ac4cb09446e7f3042ae54b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4448ee695a2b49739608d5d63ab683f9",
+            "max": 164,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_46445c615bf44a14860046004d2bac03",
+            "value": 164
+          }
+        },
+        "124f6de22f1c4b68bf3db51add98ccae": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6e9794958a7241de874513820b1b6282",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8507f3d967d4484fb9a5b4a330b36b81",
+            "value": " 164/164 [06:57&lt;00:00,  1.09it/s, train_acc=0.908, train_loss=1.97, val_acc=0.879, val_loss=1.94]"
+          }
+        },
+        "af7a51cd749b4381ad9b2f93f3575303": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bce21439b7f34c9eb0c7bb819c3b456c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b8f86628fe8946edba6c18b77129f5cc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "4448ee695a2b49739608d5d63ab683f9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "46445c615bf44a14860046004d2bac03": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "6e9794958a7241de874513820b1b6282": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8507f3d967d4484fb9a5b4a330b36b81": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "cf7be78018ac4c05be4e248c9dc64b72": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_e0a882be186d46ab94b32014ff912c10",
+              "IPY_MODEL_23beac6bc6ee4f4787d3c18bfe530d19",
+              "IPY_MODEL_4132f61fd9fc4fa8b96d0170c87b1db8"
+            ],
+            "layout": "IPY_MODEL_4f6557a722b24e68967393203217a521"
+          }
+        },
+        "e0a882be186d46ab94b32014ff912c10": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_7f7ad79be0b044bdb42850cc6ab81322",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7818092a45c449178b9112fb83284d79",
+            "value": "Epoch 5/5: 100%"
+          }
+        },
+        "23beac6bc6ee4f4787d3c18bfe530d19": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1134c3d12bd5490e84bf8d737df8a140",
+            "max": 164,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_4b5c8c748fd14e94a0a0258f702e5c7e",
+            "value": 164
+          }
+        },
+        "4132f61fd9fc4fa8b96d0170c87b1db8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bff74127b62842ac81bd5ab1ff37335e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b8a22d7541ad4272abc76cb789a857e2",
+            "value": " 164/164 [06:37&lt;00:00,  1.09it/s, train_acc=0.929, train_loss=1.7, val_acc=0.916, val_loss=1.46]"
+          }
+        },
+        "4f6557a722b24e68967393203217a521": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "7f7ad79be0b044bdb42850cc6ab81322": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "7818092a45c449178b9112fb83284d79": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1134c3d12bd5490e84bf8d737df8a140": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4b5c8c748fd14e94a0a0258f702e5c7e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "bff74127b62842ac81bd5ab1ff37335e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b8a22d7541ad4272abc76cb789a857e2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    },
+    "accelerator": "GPU"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/Contributor_demos/Chest X-Ray Images (Pneumonia) Detection/weights.hdf5 b/Contributor_demos/Chest X-Ray Images (Pneumonia) Detection/weights.hdf5
new file mode 100644
index 00000000..d13cb153
Binary files /dev/null and b/Contributor_demos/Chest X-Ray Images (Pneumonia) Detection/weights.hdf5 differ