From 837d4f23743f956422613ce4209ed2ba9ab37532 Mon Sep 17 00:00:00 2001
From: voetberg <magpie127@gmail.com>
Date: Tue, 5 May 2026 13:28:53 -0500
Subject: [PATCH 1/3] port to pytorch

---
 Challenge/challenge_utilities.py     |  221 ++--
 Challenge/guide/challenge_main.ipynb | 1735 +++++++++++++-------------
 2 files changed, 1028 insertions(+), 928 deletions(-)

diff --git a/Challenge/challenge_utilities.py b/Challenge/challenge_utilities.py
index 0e9bbb4..906a286 100644
--- a/Challenge/challenge_utilities.py
+++ b/Challenge/challenge_utilities.py
@@ -2,155 +2,190 @@
 import numpy as np
 import matplotlib.pyplot as plt
 from deepbench.astro_object import StarObject, GalaxyObject 
-import math 
-import tensorflow as tf 
+import torch
+from torch.utils.data import Dataset, DataLoader
 from sklearn.metrics import roc_curve, confusion_matrix
 
 
-class SkyGeneratorTrue(tf.keras.utils.Sequence): 
-    def __init__(self, n_samples, image_size=28, pre_processing=None, train=True, shuffle=False, batch_size=64):
+class SkyDataset(Dataset):
+    """PyTorch Dataset for generating sky images."""
+    def __init__(self, n_samples, image_size=28, pre_processing=None, shuffle=False, seed=42):
         self.n_samples = n_samples
-        self.train = train
         self.pre_processing = pre_processing
-
         self.shuffle = shuffle
-
         self.image_size = image_size
-        self.noise_level = 0.05
+        self.seed = seed
+        if not hasattr(self, 'noise_level'):
+            self.noise_level = 0.05  # Default noise level, can be overridden in subclasses
 
-        self.rng = np.random.default_rng(seed=42) # Seed for the main notebook
-        self.batch_size=batch_size
+        # Generate all data upfront
+        self.rng = np.random.default_rng(seed=seed)
         self.labels = self.decide_labels()
-
-    def decide_labels(self): 
+        self.images = self._generate_all_images()
+    
+    def _generate_all_images(self):
+        """Generate all images once and store them."""
+        images = []
+        for label in self.labels:
+            images.append(self.generate_image(label))
+        return np.stack(images)
+    
+    def decide_labels(self):
+        """Override in subclasses to change label distribution."""
         n_stars = (self.rng.integers(low=int(.45*self.n_samples), high=int(.65*self.n_samples)))
-        n_galaxies = self.n_samples-n_stars
+        n_galaxies = self.n_samples - n_stars
         labels = [0 for _ in range(n_stars)] + [1 for _ in range(n_galaxies)]
-
-        if self.shuffle: 
+        
+        if self.shuffle:
             self.rng.shuffle(labels)
-
+        
         return np.asarray(labels)
-
-    def generate_image(self, label): 
-        radius = self.rng.integers(low=1, high=self.image_size/2)
+    
+    def generate_image(self, label):
+        """Override in subclasses to change image generation."""
+        radius = self.rng.integers(low=1, high=self.image_size // 2)
         center_x = self.rng.integers(low=1, high=self.image_size)
         center_y = self.rng.integers(low=1, high=self.image_size)
-
-        if label == 0: 
+        
+        if label == 0:
             image = StarObject(
-                image_dimensions=(self.image_size, self.image_size), 
+                image_dimensions=(self.image_size, self.image_size),
                 noise_level=self.noise_level,
                 radius=radius
-                    ).create_object(
-                        center_x=center_x, center_y=center_y
-                        )
-
-        else: 
+            ).create_object(
+                center_x=center_x, center_y=center_y
+            )
+        else:
             image = GalaxyObject(
-                image_dimensions=(self.image_size, self.image_size), 
+                image_dimensions=(self.image_size, self.image_size),
                 noise_level=self.noise_level,
                 radius=radius
-                    ).create_object(
-                        center_x=center_x, center_y=center_y
-                        )
-
-        if self.pre_processing is not None: 
+            ).create_object(
+                center_x=center_x, center_y=center_y
+            )
+        
+        if self.pre_processing is not None:
             image = self.pre_processing(image)
-
+        
         return image
+    
+    def get(self, idx):
+        return self.__getitem__(idx)
 
     def __len__(self):
-        return math.ceil(self.n_samples / self.batch_size)
+        return len(self.labels)
+    
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
+        image = self.images[idx]
+        label = self.labels[idx]
+        
+        # Convert to torch tensors
+        image = torch.from_numpy(image).float()
+        label = torch.tensor(label, dtype=torch.long)
+        
+        # Add channel dimension if needed (for grayscale images)
+        if image.dim() == 2:
+            image = image.unsqueeze(0)
+        
+        return image, label
 
-    def __getitem__(self, idx):
-        low = idx * self.batch_size
-        high = min(low + self.batch_size, len(self.labels))
-        batch_y = self.labels[low:high]
-        batch_x = np.zeros((len(batch_y), self.image_size, self.image_size))
-        for index, label in enumerate(batch_y): 
-            batch_x[index] = self.generate_image(label)
-        return batch_x, batch_y
 
+class SkyGenerator:
+    """Factory class that returns PyTorch DataLoader for SkyDataset."""
+    def __init__(self, n_samples, dataset, shuffle=False, batch_size=64, seed=42, transform=None):
+        self.dataset = dataset(n_samples, seed=seed)
+        self.shuffle = shuffle
+        self.batch_size = batch_size
+    
+    def get_dataloader(self):
+        """Return a PyTorch DataLoader."""
+        return DataLoader(
+            self.dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+        )
+    
+    def __len__(self):
+        return len(self.dataset)
 
-class SkyGenerator01(SkyGeneratorTrue):
-    def __init__(self, n_samples, pre_processing=None, train=True, shuffle=False, batch_size=64):
-        image_size = 28
-        super().__init__(n_samples, image_size, pre_processing, train, shuffle, batch_size)
 
+class SkyDataset01(SkyDataset):
+    def __init__(self, n_samples, seed=42, shuffle=False):
+        super().__init__(n_samples, image_size=64, pre_processing=None, seed=seed, shuffle=shuffle)
 
-class SkyGenerator02(SkyGeneratorTrue): 
-    def __init__(self, n_samples, pre_processing=None, train=True, shuffle=False, batch_size=64):
-        image_size = 28
-        super().__init__(n_samples, image_size, pre_processing, train, shuffle, batch_size)
 
-    def decide_labels(self): 
+class SkyDataset02(SkyDataset):
+    def __init__(self, n_samples, seed=42, shuffle=False):
+        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+    
+    def decide_labels(self):
         n_stars = (self.rng.integers(low=int(.85*self.n_samples), high=int(.95*self.n_samples)))
-        n_galaxies = self.n_samples-n_stars
+        n_galaxies = self.n_samples - n_stars
         labels = [0 for _ in range(n_stars)] + [1 for _ in range(n_galaxies)]
-
-        if self.shuffle: 
+        
+        if self.shuffle:
             self.rng.shuffle(labels)
-
+        
         return np.asarray(labels)
-    
-class SkyGenerator03(SkyGeneratorTrue): 
-    def __init__(self, n_samples, pre_processing=None, train=True, shuffle=False, batch_size=64):
-        image_size = 64
-        super().__init__(n_samples, image_size, pre_processing, train, shuffle, batch_size)
+
+
+class SkyDataset03(SkyDataset):
+    def __init__(self, n_samples, seed=42, shuffle=False):
+        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
 
     def decide_labels(self):
         n_stars = int((self.rng.integers(low=int(.15*self.n_samples), high=int(.25*self.n_samples))))
-        n_galaxies = int(.5 * (self.n_samples-n_stars))
-        wild_card = self.n_samples - (n_stars+n_galaxies)
+        n_galaxies = int(.5 * (self.n_samples - n_stars))
+        wild_card = self.n_samples - (n_stars + n_galaxies)
         labels = [0 for _ in range(n_stars)] + [1 for _ in range(n_galaxies)] + [2 for _ in range(wild_card)]
-
-        if self.shuffle: 
+        
+        if self.shuffle:
             self.rng.shuffle(labels)
-
+        
         return np.asarray(labels)
     
     def generate_image(self, label):
-        if label == 2: 
+        if label == 2:
             return np.zeros((self.image_size, self.image_size))
-        else: 
+        else:
             return super().generate_image(label)
     
     def __getitem__(self, idx):
-        items, labels = super().__getitem__(idx)
-        labels[labels == 2] = 0
-        return items, labels
-
-class SkyGenerator04(SkyGeneratorTrue): 
-    def __init__(self, n_samples, pre_processing=None, train=True, shuffle=False, batch_size=64):
-        image_size = 28
-        super().__init__(n_samples, image_size, pre_processing, train, shuffle, batch_size)
-        
-    def decide_labels(self): 
+        image, label = super().__getitem__(idx)
+        # Convert label 2 (wildcard) to label 0 (Star)
+        label = torch.where(label == 2, torch.tensor(0), label)
+        return image, label
+
+
+class SkyDataset04(SkyDataset):
+    def __init__(self, n_samples, seed=42, shuffle=False):
+        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+
+    def decide_labels(self):
         n_stars = (self.rng.integers(low=int(.45*self.n_samples), high=int(.65*self.n_samples)))
-        n_galaxies = (self.rng.integers(low=int(.6*(self.n_samples-n_stars)), high=int(.9*(self.n_samples-n_stars))))
-        wild_card = self.n_samples - (n_stars+n_galaxies)
+        n_galaxies = (self.rng.integers(low=int(.6*(self.n_samples - n_stars)), high=int(.9*(self.n_samples - n_stars))))
+        wild_card = self.n_samples - (n_stars + n_galaxies)
         labels = [0 for _ in range(n_stars)] + [1 for _ in range(n_galaxies)] + [2 for _ in range(wild_card)]
-
-        if self.shuffle: 
+        
+        if self.shuffle:
             self.rng.shuffle(labels)
-
+        
         return np.asarray(labels)
-    
-class SkyGenerator05(SkyGeneratorTrue): 
-    def __init__(self, n_samples, pre_processing=None, train=True, shuffle=False, batch_size=64):
-        image_size = 28
-        super().__init__(n_samples, image_size, pre_processing, train, shuffle, batch_size)
+
+
+class SkyDataset05(SkyDataset):
+    def __init__(self, n_samples, seed=42, shuffle=False):
+        self.noise_level = 0.25  # Increase noise level for this dataset
+        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+
 
 class Eval: 
     @staticmethod
-    def plot_loss_history(history): 
-        loss = history['loss']
-        epochs = range(len(loss))
+    def plot_loss_history(train_loss, val_loss): 
+        epochs = range(len(train_loss))
 
-        val_loss = history['val_loss']
 
-        plt.plot(epochs, loss, label="Train", marker='o')
+        plt.plot(epochs, train_loss, label="Train", marker='o')
         plt.plot(epochs, val_loss, label='Validation', marker='x')
 
         plt.title("Loss History")
diff --git a/Challenge/guide/challenge_main.ipynb b/Challenge/guide/challenge_main.ipynb
index a7bb286..8dcd9f7 100644
--- a/Challenge/guide/challenge_main.ipynb
+++ b/Challenge/guide/challenge_main.ipynb
@@ -1,888 +1,953 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Training Challenge! \n",
-    "\n",
-    "In this notebook, there are a whole host of weird errors. \n",
-    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking. \n",
-    "Do your best to sniff out the mistakes in both code and training procedure! \n",
-    "\n",
-    "Your mission, should you choose to accept it, is: \n",
-    "* Work together in groups of 4 to complete this notebook\n",
-    "* Figure out all the coding mistakes and make a notebook that runs\n",
-    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them.\n",
-    "\n",
-    "### Rules \n",
-    "* If you cannot correct the problem, identify it and write a quick paragraph about what you would do\n",
-    "* You are allowed to use any resource you can find; other groups, TA's, a random scientist walking by, and most importantly, the internet. The use of generative AI is highly discouraged - not because it's cheating, but because it can send you down rabbit holes that are hard to find your way out of. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This line below installs a non-standard data generation package. \n",
-    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator. \n",
-    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it. \n",
-    "The `!` point here means \"Execute this line like it's a line in a bash prompt\". "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! pip install deepbench"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`curl` is a package for downloading files off the internet. \n",
-    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\". \n",
-    "This file is also in the github repo, you can look at it there if you want. \n",
-    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results. \n",
-    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials_2024/tree/main/07_Challenge/challenge_utilities.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we'll import the different classes from this new file \n",
-    "from challenge_utilities import SkyGeneratorTrue as SkyGenerator # `as` renames the imported package name\n",
-    "from challenge_utilities import Eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Standard packages \n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from tensorflow.keras.layers import Input, Dropout, Conv1D, Dense, AvgPool1D, Flatten\n",
-    "from tensorflow.keras.models import Model\n",
-    "\n",
-    "import tensorflow as tf \n",
-    "from sklearn.preprocessing import MinMaxScaler"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Package documentation \n",
-    "\n",
-    "If you get stuck for syntax or anything - these are the packages used. \n",
-    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names. \n",
-    "\n",
-    "[Numpy](https://numpy.org/)\n",
-    "\n",
-    "[MatPlotLib](https://matplotlib.org/) \n",
-    "\n",
-    "[Tensorflow/tf/Keras](https://keras.io/)\n",
-    "\n",
-    "[Scikit Learn](https://scikit-learn.org/stable/index.html)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Exploratory Data Analysis \n",
-    "\n",
-    "Understanding your data is a critical part of any AI/ML project. \n",
-    "Make sure you look at your data and understand the differences between each class. \n",
-    "\n",
-    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
-    "You can use this to label your plots. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 9 Axes>"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jToNcYCsARAt"
+      },
+      "source": [
+        "## Model Training Challenge!\n",
+        "\n",
+        "In this notebook, there are a whole host of weird errors.\n",
+        "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+        "Do your best to sniff out the mistakes in both code and training procedure!\n",
+        "\n",
+        "Your mission, should you choose to accept it, is:\n",
+        "* Work together in groups of 4 to complete this notebook\n",
+        "* Figure out all the coding mistakes and make a notebook that runs\n",
+        "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+        "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "\n",
-    "label_map = {\n",
-    "    0: \"Star\", \n",
-    "    1: \"Galaxy\"\n",
-    "}\n",
-    "\n",
-    "\n",
-    "def plot_samples(generator, n_columns=3, n_rows=3, label_map=None): \n",
-    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid \n",
-    "    plt.tight_layout()\n",
-    "    plt.setp(subplots, xticks=[], yticks=[])\n",
-    "\n",
-    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()): \n",
-    "        image, label = generator[sample_index]\n",
-    "        subplot.imshow(image.squeeze()) \n",
-    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels). \n",
-    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-    "        \n",
-    "        string_label = \"??\" \n",
-    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-    "\n",
-    "samples = SkyGenerator(n_samples=9, batch_size=1) # Can just get a few samples\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Look at the input data \n",
-    "\n",
-    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# These two generators produce the data we'll train with \n",
-    "\n",
-    "n_train_samples = 1280\n",
-    "train_generator = SkyGenerator(n_samples=n_train_samples, shuffle=True)\n",
-    "\n",
-    "n_val_samples = 1280\n",
-    "val_generator = SkyGenerator(n_samples=n_val_samples, train=False, shuffle=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RX8h5B-GARAt"
+      },
+      "source": [
+        "This line below installs a non-standard data generation package.\n",
+        "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+        "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+        "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# We can look at the distribution of labels by grabbing them from the generator \n",
-    "    # TF.Sequence generators supply data as a tuple \n",
-    "    # of (x,y) (or (features, labels)) \n",
-    "    # - so using index 1 we can get the labels\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][1] for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][1] for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.supxlabel(\"Label Distributions\")\n",
-    "figure.supylabel(\"Label Frequency\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "VPUeGpTrARAu",
+        "outputId": "3c57ef4c-fddf-4249-d1d3-9d54be9dd48d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting deepbench\n",
+            "  Downloading deepbench-0.2.3-py3-none-any.whl.metadata (6.4 kB)\n",
+            "Collecting astropy<6.0.0,>=5.2.2 (from deepbench)\n",
+            "  Downloading astropy-5.3.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.4 kB)\n",
+            "Requirement already satisfied: autograd<2.0,>=1.5 in /usr/local/lib/python3.12/dist-packages (from deepbench) (1.8.0)\n",
+            "Requirement already satisfied: h5py>=3.9.0 in /usr/local/lib/python3.12/dist-packages (from deepbench) (3.16.0)\n",
+            "Requirement already satisfied: matplotlib<4.0.0,>=3.7.1 in /usr/local/lib/python3.12/dist-packages (from deepbench) (3.10.0)\n",
+            "Collecting numpy<2.0.0,>=1.25.0 (from deepbench)\n",
+            "  Downloading numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.0/61.0 kB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: pyyaml<7.0,>=6.0 in /usr/local/lib/python3.12/dist-packages (from deepbench) (6.0.3)\n",
+            "Collecting scikit-image<0.24.0,>=0.23.0 (from deepbench)\n",
+            "  Downloading scikit_image-0.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (14 kB)\n",
+            "Requirement already satisfied: pyerfa>=2.0 in /usr/local/lib/python3.12/dist-packages (from astropy<6.0.0,>=5.2.2->deepbench) (2.0.1.5)\n",
+            "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.12/dist-packages (from astropy<6.0.0,>=5.2.2->deepbench) (26.1)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (4.62.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (1.5.0)\n",
+            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (11.3.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (3.3.2)\n",
+            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (2.9.0.post0)\n",
+            "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (1.16.3)\n",
+            "Requirement already satisfied: networkx>=2.8 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (3.6.1)\n",
+            "Requirement already satisfied: imageio>=2.33 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (2.37.3)\n",
+            "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (2026.4.11)\n",
+            "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (0.5)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.7.1->deepbench) (1.17.0)\n",
+            "INFO: pip is looking at multiple versions of tifffile to determine which version is compatible with other requirements. This could take a while.\n",
+            "Collecting tifffile>=2022.8.12 (from scikit-image<0.24.0,>=0.23.0->deepbench)\n",
+            "  Downloading tifffile-2026.5.2-py3-none-any.whl.metadata (32 kB)\n",
+            "  Downloading tifffile-2026.3.3-py3-none-any.whl.metadata (31 kB)\n",
+            "Downloading deepbench-0.2.3-py3-none-any.whl (33 kB)\n",
+            "Downloading astropy-5.3.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.3 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.3/10.3 MB\u001b[0m \u001b[31m76.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.0/18.0 MB\u001b[0m \u001b[31m71.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading scikit_image-0.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (14.9 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.9/14.9 MB\u001b[0m \u001b[31m77.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading tifffile-2026.3.3-py3-none-any.whl (243 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m244.0/244.0 kB\u001b[0m \u001b[31m18.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: numpy, tifffile, scikit-image, astropy, deepbench\n",
+            "  Attempting uninstall: numpy\n",
+            "    Found existing installation: numpy 2.0.2\n",
+            "    Uninstalling numpy-2.0.2:\n",
+            "      Successfully uninstalled numpy-2.0.2\n",
+            "  Attempting uninstall: tifffile\n",
+            "    Found existing installation: tifffile 2026.4.11\n",
+            "    Uninstalling tifffile-2026.4.11:\n",
+            "      Successfully uninstalled tifffile-2026.4.11\n",
+            "  Attempting uninstall: scikit-image\n",
+            "    Found existing installation: scikit-image 0.25.2\n",
+            "    Uninstalling scikit-image-0.25.2:\n",
+            "      Successfully uninstalled scikit-image-0.25.2\n",
+            "  Attempting uninstall: astropy\n",
+            "    Found existing installation: astropy 7.2.0\n",
+            "    Uninstalling astropy-7.2.0:\n",
+            "      Successfully uninstalled astropy-7.2.0\n",
+            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+            "jax 0.7.2 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
+            "xarray-einstats 0.10.0 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
+            "pytensor 2.38.2 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
+            "jaxlib 0.7.2 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
+            "shap 0.51.0 requires numpy>=2, but you have numpy 1.26.4 which is incompatible.\n",
+            "opencv-python 4.13.0.92 requires numpy>=2; python_version >= \"3.9\", but you have numpy 1.26.4 which is incompatible.\n",
+            "tobler 0.14.0 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
+            "opencv-python-headless 4.13.0.92 requires numpy>=2; python_version >= \"3.9\", but you have numpy 1.26.4 which is incompatible.\n",
+            "opencv-contrib-python 4.13.0.92 requires numpy>=2; python_version >= \"3.9\", but you have numpy 1.26.4 which is incompatible.\n",
+            "rasterio 1.5.0 requires numpy>=2, but you have numpy 1.26.4 which is incompatible.\u001b[0m\u001b[31m\n",
+            "\u001b[0mSuccessfully installed astropy-5.3.4 deepbench-0.2.3 numpy-1.26.4 scikit-image-0.23.2 tifffile-2026.3.3\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.colab-display-data+json": {
+              "pip_warning": {
+                "packages": [
+                  "numpy"
+                ]
+              },
+              "id": "eb01b87d27a04ef696a480954b2b96e9"
+            }
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "! pip install deepbench"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xatOAXZ6ARAu"
+      },
+      "source": [
+        "`curl` is a package for downloading files off the internet.\n",
+        "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+        "This file is also in the github repo, you can look at it there if you want.\n",
+        "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+        "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# We can also look at different attributes of the images \n",
-    "# Here, let's look at max values and mean values\n",
-    "\n",
-    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated \n",
-    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().mean() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].mean() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Mean value of pixels in a single image\")\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().max() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].ravel().max() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Max value of pixels in a single image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Processing\n",
-    "\n",
-    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-    "There are near infinite ways to pre-process, especially in the computer vision space. \n",
-    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways. \n",
-    "\n",
-    "For this, let's try bringing all the pixels in the image between 0 and 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "scaler = MinMaxScaler((0, 1))\n",
-    "\n",
-    "fit_data = np.concatenate([train_generator[i][0] for i in range(5)], axis=0) \n",
-    "# This is 5 batches of data, being used to find the approximate min and max of the data\n",
-    "# Because our data is synthetic, we don't need to worry about big outliers\n",
-    "\n",
-    "# Unfortunately, minmaxscaler only handles 1d of data, so we need to do a little pre-and-post processing on the input \n",
-    "# combining the last two dimensions together, making the 2d of the image 1d instead. \n",
-    "fit_data = fit_data.reshape((fit_data.shape[0], fit_data.shape[1]*fit_data.shape[2]) ) \n",
-    "scaler_fit = scaler.fit(fit_data)\n",
-    "\n",
-    "def processor(image): \n",
-    "    # This function will take a single image and return the scaled version \n",
-    "    image_flat = image.ravel() \n",
-    "    image_scaled = scaler_fit.transform(image_flat.reshape(1, -1))\n",
-    "    # Magically reshape it back into 2d \n",
-    "    image_scaled_reshaped = image_scaled.reshape(image.shape)\n",
-    "    return image_scaled_reshaped"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_generator_scaled = SkyGenerator(n_samples=n_train_samples, pre_processing=processor, batch_size=64)\n",
-    "val_generator_scaled = SkyGenerator(n_samples=n_val_samples, pre_processing=processor, batch_size=64)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 9 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Kjo3hTS_ARAu",
+        "outputId": "552163ed-0b63-4895-8337-5b03e44fb881"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
+            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
+            "100  7248  100  7248    0     0  54291      0 --:--:-- --:--:-- --:--:--     0--:-- --:--:-- --:--:-- 54496\n"
+          ]
+        }
+      ],
+      "source": [
+        "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Look at some processed samples! \n",
-    "\n",
-    "n_samples = 9\n",
-    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, pre_processing=processor)\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Make the binary classification model \n",
-    "\n",
-    "This function, when called, produces a keras Model instance that you can train to predict a class of an input. \n",
-    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1. \n",
-    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out. \n",
-    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it. \n",
-    "\n",
-    "In this case, what we want: \n",
-    "* Take the input images from the data generator \n",
-    "* Apply two convolutional blocks to the input image \n",
-    "* Decode the second convolution block's output to a probability of the image being a given class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional_1\"</span>\n",
-       "</pre>\n"
-      ],
-      "text/plain": [
-       "\u001b[1mModel: \"functional_1\"\u001b[0m\n"
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "MKc8rBCmARAu"
+      },
+      "outputs": [],
+      "source": [
+        "# Now we'll import the different classes from this new file\n",
+        "# Import the dataloader and dataset classes\n",
+        "from challenge_utilities import SkyDataset # Dataset object itself\n",
+        "# A subclass of torch.utils.data.Dataset\n",
+        "from challenge_utilities import SkyGenerator # Generic dataloader object, same for all challenges\n",
+        "from challenge_utilities import Eval"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "2IXmuM_EARAv"
+      },
+      "outputs": [],
+      "source": [
+        "# Standard packages\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "import torch\n",
+        "import torchvision\n",
+        "from torchsummary import summary"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "W9XZQhfDARAv"
+      },
+      "source": [
+        "#### Package documentation\n",
+        "\n",
+        "If you get stuck for syntax or anything - these are the packages used.\n",
+        "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+        "\n",
+        "[MatPlotLib](https://matplotlib.org/)\n",
+        "\n",
+        "[Pytorch](https://docs.pytorch.org/docs/)\n"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
-       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
-       "│ input_layer (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)        │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">28</span>)         │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ conv1d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv1D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">27</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>)          │           <span style=\"color: #00af00; text-decoration-color: #00af00\">228</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ conv1d_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv1D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">24</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>)          │           <span style=\"color: #00af00; text-decoration-color: #00af00\">136</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ conv1d_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv1D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">19</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>)         │           <span style=\"color: #00af00; text-decoration-color: #00af00\">588</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ average_pooling1d_1             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>)          │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
-       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">AveragePooling1D</span>)              │                        │               │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">36</span>)             │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">20</span>)             │           <span style=\"color: #00af00; text-decoration-color: #00af00\">740</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">20</span>)             │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)              │            <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span> │\n",
-       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
-       "</pre>\n"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "m5EFoTAgARAv"
+      },
+      "source": [
+        "# Exploratory Data Analysis\n",
+        "\n",
+        "Understanding your data is a critical part of any AI/ML project.\n",
+        "Make sure you look at your data and understand the differences between each class.\n",
+        "\n",
+        "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+        "You can use this to label your plots."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 477
+        },
+        "id": "66Gal0ukARAv",
+        "outputId": "caed553d-8a96-4e5d-cee8-1b60be4310fe"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 9 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
       ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
-       "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m)        │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m28\u001b[0m, \u001b[38;5;34m28\u001b[0m)         │             \u001b[38;5;34m0\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ conv1d_3 (\u001b[38;5;33mConv1D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m27\u001b[0m, \u001b[38;5;34m4\u001b[0m)          │           \u001b[38;5;34m228\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ conv1d_4 (\u001b[38;5;33mConv1D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m24\u001b[0m, \u001b[38;5;34m8\u001b[0m)          │           \u001b[38;5;34m136\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ conv1d_5 (\u001b[38;5;33mConv1D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m19\u001b[0m, \u001b[38;5;34m12\u001b[0m)         │           \u001b[38;5;34m588\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ average_pooling1d_1             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m12\u001b[0m)          │             \u001b[38;5;34m0\u001b[0m │\n",
-       "│ (\u001b[38;5;33mAveragePooling1D\u001b[0m)              │                        │               │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ flatten (\u001b[38;5;33mFlatten\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m36\u001b[0m)             │             \u001b[38;5;34m0\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ dense (\u001b[38;5;33mDense\u001b[0m)                   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m)             │           \u001b[38;5;34m740\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ dropout (\u001b[38;5;33mDropout\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m)             │             \u001b[38;5;34m0\u001b[0m │\n",
-       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
-       "│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)              │            \u001b[38;5;34m21\u001b[0m │\n",
-       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      "source": [
+        "\n",
+        "label_map = {\n",
+        "    0: \"Star\",\n",
+        "    1: \"Galaxy\"\n",
+        "}\n",
+        "\n",
+        "def plot_samples(generator, n_columns=3, n_rows=3, label_map:dict|None=None):\n",
+        "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+        "    plt.tight_layout()\n",
+        "    plt.setp(subplots, xticks=[], yticks=[])\n",
+        "\n",
+        "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+        "        image, label = generator.get(sample_index)\n",
+        "        subplot.imshow(image.squeeze())\n",
+        "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+        "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+        "\n",
+        "        string_label = label_map[label.item()] if label_map else str(label.item())\n",
+        "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+        "\n",
+        "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+        "plot_samples(samples, label_map=label_map)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VTG-xMYWARAw"
+      },
+      "source": [
+        "# Look at the input data\n",
+        "\n",
+        "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "6FJGVsZgARAw"
+      },
+      "outputs": [],
+      "source": [
+        "# These two generators produce the data we'll train with\n",
+        "\n",
+        "n_train_samples = 1280\n",
+        "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+        "\n",
+        "n_val_samples = 1280\n",
+        "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,713</span> (6.69 KB)\n",
-       "</pre>\n"
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 470
+        },
+        "id": "KM_sOu9sARAw",
+        "outputId": "92e2f0b1-4808-49d4-9049-67a799d21ca6"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0.5, 1.0, 'Val labels')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
       ],
-      "text/plain": [
-       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,713\u001b[0m (6.69 KB)\n"
+      "source": [
+        "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+        "\n",
+        "fig, ax = plt.subplots(1,2)\n",
+        "ax[0].hist(train_generator.dataset.labels)\n",
+        "ax[0].set_title(\"Train labels\")\n",
+        "ax[1].hist(val_generator.dataset.labels)\n",
+        "ax[1].set_title(\"Val labels\")\n",
+        "\n"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,713</span> (6.69 KB)\n",
-       "</pre>\n"
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "id": "TwAsJhDMARAw",
+        "outputId": "4899a0d7-1e6e-41c7-ca20-47fafb717a9a"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
       ],
-      "text/plain": [
-       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m1,713\u001b[0m (6.69 KB)\n"
+      "source": [
+        "# We can also look at different attributes of the images\n",
+        "# Here, let's look at max values and mean values\n",
+        "\n",
+        "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+        "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+        "\n",
+        "# Normally we would also have some metadata to work with, but here we only have images\n",
+        "\n",
+        "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+        "\n",
+        "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+        "\n",
+        "figure, subplots = plt.subplots(1, 2)\n",
+        "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+        "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+        "subplots[0].legend()\n",
+        "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+        "\n",
+        "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+        "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+        "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+        "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+        "subplots[1].set_xlabel(\"Max pixel value\")\n",
+        "\n",
+        "\n",
+        "plt.show()"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "text/html": [
-       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
-       "</pre>\n"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "NhRpPEjdARAw"
+      },
+      "source": [
+        "## Data Processing\n",
+        "\n",
+        "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+        "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+        "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+        "\n",
+        "For this, let's try bringing all the pixels in the image between 0 and 1."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "Wp_k5XTiARAw"
+      },
+      "outputs": [],
+      "source": [
+        "# Torch uses \"transforms\" to apply a series of transforms to the data as its being loaded\n",
+        "# We can define this as a set of transforms we can apply either as part of the dataloader,\n",
+        "# or as a separate step after loading the data.\n",
+        "\n",
+        "transforms = torchvision.transforms.Compose([\n",
+        "    torchvision.transforms.Resize((64, 64)), # Resize the images to 64 x 64 pixels\n",
+        "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+        "])\n",
+        "\n",
+        "# We can apply other transforms, in a process called \"data augmentation\"\n",
+        "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+        "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "6gXn05XNARAx",
+        "outputId": "32dbf946-86b8-419a-a03e-8fd4d893158f"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGzCAYAAABpdMNsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASf5JREFUeJzt3XuUXXV5PvBn73Od++Q6k0gSws9ogpAICYQRvBSikSqLmKlFi21Uli5ogkLqUrOWgLKUoVgF0RDU0oBLaWraBm8LKI0mtpggRCggNgaMJprMJCSZ+8y5fn9/pIye7PcJs5Mz2WdOns9asxZ8Z2effT3fObOfeV/POecgIiJyivlRb4CIiJyeNAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgk4mO14rVr1+KLX/wiOjs7sWDBAnz1q1/FhRde+Kr/rlgsYt++fWhoaIDneWO1eSIiMkacc+jr68P06dPh+8f5nOPGwIYNG1wymXT/9E//5H75y1+6j3zkI665udl1dXW96r/du3evA6AvfelLX/oa51979+497vu951z5i5EuXrwYF1xwAb72ta8BOPqpZsaMGbj++uvx6U9/+rj/tqenB83NzXjTRZ9EPJ4q+Z6XLZr/Jn54IDh4pMdc1g0P2+OZrD1ePPnD4/kV/knOK9NvYsl+mh9kYzF7FZMnmuO5lmZzvH9mjTneMzu4T9lJ9vVT/1t7/5t258zx9MvBayh2kF1v9nXF0E/91ji7rthPnDEybqzbsXWE2b6oWG9p5G3OY29/bLxoX0Ow3ifCLHuc16Rv0dZ6HHnNsG/zxcLoXo/Iuyy29n0X3d3daGpqosuV/Vdw2WwWO3bswJo1a0bGfN/HkiVLsG3btsDymUwGmUxm5P/7+vqOblg8hXg8XbKsR05oPJYPDvpJc1nn2etwHjn5ZDyMiv9VYrkmILKf5v57ZALyU+a4O+ZaeEU8YY/HUsF98tP2ubeWPbpuexvjxnDMJz/YhDy04SYgsvKw49YEFGKyOu54FMJMQCEnA4C8wcNani0bbpLgnxHGcAJyxgR0Au+Fr/beV/YQwssvv4xCoYCWlpaS8ZaWFnR2dgaW7+joQFNT08jXjBkzyr1JIiJSgSJPwa1ZswY9PT0jX3v37o16k0RE5BQo+6/gJk+ejFgshq6urpLxrq4utLa2BpZPpVJIpexfu4iISPUq+wSUTCaxcOFCbN68GcuWLQNwNISwefNmrFq1atTrydYnUEwkSsZiJIQQGww+7/HjZNfIw2/2281QAQKybo+M09+bG7+vdQXjd7JAqAeDR1fEfi8dwliGKsjvqv2cvf+xjL18YjA4Vuyztzs+xF6THNu8cQzLEFY5Luv5Dbt+2PMb8gzIWQ+1rDHwcELoh/knuyxQlmPOntGRR8X8mFvrcSFDIuweZ8z7kLwHhXx25/JWCCHEe5Aj73nHGJO/A1q9ejVWrFiBRYsW4cILL8Rdd92FgYEBfOhDHxqLlxMRkXFoTCagq666CgcPHsTNN9+Mzs5OvPGNb8QjjzwSCCaIiMjpa8wqIaxatSrUr9xEROT0EnkKTkRETk+agEREJBJj9iu4k9VzVhyxVOnmJQbs1Esj6gJj6QH7L9Np0uZPqjG8Go8k7LykXX3BS5OYOVmPywbLt3hD5C/t80YVCBwvNVchP3Owv/oets+D3ztkjtd0sYRhsEJC9pC97zUv28cwedg+5v6gsY2s7ApBU0lhEpMk7eYS5LZOJszhYk1wvGCMAaA/sno5e/99Mm4lCVmlE14Wh2xLiEoIKJDKKD57TVLtg6wnzGvSFC1bj5WmK9M1AaM0mcfKShnvNR45TseqkHcjERE53WgCEhGRSGgCEhGRSGgCEhGRSFRsCGFwuoOfLn0QmCClVJJ9wd1IddoP/n3yII0+FDYe9NGwQa3dm8bV19rjafsBoMcCFNayLDwxTB6u0qJDFSJr9+DxevvN8YRVMgRAbDC4nmLavtz9Qfua8PvJecgZoQUS+ghbAiVUeR0WWGBhg1r7us01BMdzjawUDylnNEjKZA3bx8XPBsetsaMvGi6EYC7PAg6stBBb3s6rmHdV6IJVrLQQK31lnH+XIue+zn4/ZGGT2GDwXvFZuxWzbI+5aHCdo1tMRESkvDQBiYhIJDQBiYhIJDQBiYhIJDQBiYhIJCo2BVe/x0MsWZq6iA/aKZGag8HEE0swOaPEBAA41gjNKJdD027NDeZ4dmqwVBAA5Orsw586FEwlsRPFUlbOSmoBvAyIJWTjuTBJQt6Mj6T3SMkhj5xPv9dYdoiUUGLHio1bCSm2PwxLsLFmclbiiTSNo2m3Rnt8aHIwCTU0mZR0YcG7Hnv5VJ89Hh8Mrig+xK5Z+970WKDTSJOxUjm0hE4+XDM5z0hBOo8kIwssAUmufdYc0CjxVay3z3Fmop2CyzTb6051B++VNNv3jJE4LYzus40+AYmISCQ0AYmISCQ0AYmISCQ0AYmISCQ0AYmISCQqNgXX9Jsc4onShAarK5U8OBAYcwOD9opDNJ47uvJgQsjVBpudAUC+2U7HDU61kynZRpacCiZWYkP2ulmCyzNSRgDgfJI0CoGm3crAsbQSKcLFljfPM0meha2OZ+5/mAQgwNNuZHkzCUWajBVq7fFskz1uJd4GXkMaBpIUXCFF0phkP5Px4PKOHUKSgmO106zlvTxLr5FGev7oG+kx7C5x7FphTdzIeS7WBt+beNLRXsdgi/2ahURw3M/a644PBS+KwijfZvQJSEREIqEJSEREIqEJSEREIqEJSEREIqEJSEREIlGxKbj4cB7xY+p/eVmSQAnRoZLVfKPdCI2UDEue+cN2N89kv911EJ4dKYoPBrfdy5JYCekISvczBJp2I2kyj6R1kAimZzzStZN1rnSsQyU5z2ZXTFJPjncnZQk2Y3mWdmPjrIYfrQUXHHdxkpgLW8PPuPb9nL2OIskMOrLZBTs4hVyNtX5yXbFacKzJac7YnzxJzOXI9RYj6bgcud6s/bffDsJ3SiXM80beI+ND9niy1z5xCaPDbSxDjonV3Zbdl8cuN6qlREREykwTkIiIREITkIiIREITkIiIRKJiQwiVwmWNhmcDQ+ayPmkclSYPnBO99oP4eE9w/V6fXVrIsdJCo3wIeFysAVXSfrLspcgTZ6OBX5GUM7IaewGAN0T2kzUYtMIZRXJMWNiAPcwPVYonbIkeUi7IbEgX7udH9jA/ZvRuTPTZ6ygaJVoAgFV4ckbJHQAopIPbUiTL+qSBG+n3ZgYOYlmy7xl73TEraALQH9nNYVa1h4yHDSdYwaT4gL2WNLkO48P29ZboM9bdazf5tLbDL4yu5Jk+AYmISCQ0AYmISCQ0AYmISCQ0AYmISCQ0AYmISCQqNgU3PDGJ+DElXGLDrBREMFEV6yOlXkg5Flq4JkRJF5bU8lnpGlLWwxsMrsdM4x1nW1hJm1DYdqeDDfMAwNXXmuP5yQ2BsexEOzEXIyVDEkfsBI5P0oHWuXCklAhDSxFZCbaQDenClNwBABiJN7YO2vCMsBJscftwk7aAvBRP3u6jCFileMhN6LPwItmYmHGrxIZJCiwervFeGD4p7+WxMlm0TBhp0mg0x/MK9vtEgqwjNmRPAbHB4Hq8AZKCMxKnXlEpOBERqWCagEREJBKagEREJBKagEREJBKagEREJBIVm4LrmR1DLFUaRYkPkGiKC6avavtIYoMkTbzh0aU2TkjIBmGnGkt7eXH78mBpt8KkenO8f2YwCtX/Gvtnn2SvfX7q/2Avn2ZhMiuBlCUdwsKeH+t4hakbB/B0HBu3UnCsIR2pqUYb1YXZ/ZCN5wqp0afMWJKO1ZljTfOs+m7xAXsdNO1G6gOyJnhWQ0svT+r6seaXLO3myAkymmWyJJ1PGlf6vp2a8zLGvcLuH+s1iywveczrj2opERGRMtMEJCIikdAEJCIikdAEJCIikQg9Af30pz/FFVdcgenTp8PzPDz00EMl33fO4eabb8a0adNQU1ODJUuWYNeuXeXaXhERqRKhU3ADAwNYsGABPvzhD2P58uWB799xxx24++678cADD2D27Nm46aabsHTpUrzwwgtIp+0umJbsBAf/mK6JrBtjrsHoFpm0a8GxZBdlpZhovS6SeknY48UUqcOUDY7TRBpNdrG4kpGGod05Scqqxo485Rrt8aEpwfUMnGEnfvKH7NdMDJLOjf32a/pGLSuQbpG05luYcbJsOWq+ASQFl7CXLZJunizxZaXPWPCqSG6ffJ2dvsrX2efZJY3lkyRiliWJNJKCiw8YxypsSpHVpcuz7qzB1ywanVnZsgDg5dnnAXJcjPSZlwtZG9JK0gHm+4Rj6zBSfW6UKbjQE9Dll1+Oyy+/3Pyecw533XUXPvOZz+DKK68EAHzrW99CS0sLHnroIbzvfe8L+3IiIlKlyvoMaPfu3ejs7MSSJUtGxpqamrB48WJs27bN/DeZTAa9vb0lXyIiUv3KOgF1dnYCAFpaWkrGW1paRr53rI6ODjQ1NY18zZgxo5ybJCIiFSryFNyaNWvQ09Mz8rV3796oN0lERE6Bsk5Ara2tAICurq6S8a6urpHvHSuVSqGxsbHkS0REql9Za8HNnj0bra2t2Lx5M974xjcCAHp7e/HEE0/guuuuC7Wuht8CsWMCTnHSLbO2K1jHze+3O2W6YdLqkfASRiKtxm7zWGy2a6FlWurM8Vy9HUtKHwy+ZoKkVTySTHGsa2s5OqUSLDl1WgiZpKM131iCzUhxFUmSrpi011EgKdK8EU7N25csco12sivXbNcaSzTZNRbTNcGUYl3Krks2mCHpymE76ZozOvY6j7zVkYvWI2m3WNYet9JxzqhJBxynky059yyl6lmF6UJ2w6VdWE+R0BNQf38/XnzxxZH/3717N5555hlMnDgRM2fOxA033IDPf/7zmDNnzkgMe/r06Vi2bFk5t1tERMa50BPQU089hT/7sz8b+f/Vq1cDAFasWIH7778fn/zkJzEwMICPfvSj6O7uxiWXXIJHHnkk1N8AiYhI9Qs9Ab3tbW+DO87HNs/zcOutt+LWW289qQ0TEZHqFnkKTkRETk8V25Cu6aUM4sc01vIz9oPO+KH+wJjrtztQuYz9oJN9qrNK4Lia4ENOAMg3279mHJxiH+ZME5n/XfCha2zQXneMlN7whobsVZPKPRUjbJAhxI9QoUvusBJFVlkXtg5aiidkozpjPaw0VZE0pCuwcEI6OJ6vJWGDRvseTE20r7dpE+w/LG+p7QuMtabtZV/O2OGeg0P2+B+STYGxgYKdqvBJ0zgWNigMkXFj+RgpleRnSRCIXm/2MR/TRpenKJygT0AiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhKJik3BJTv7EI+VJtZos6XBYAKnSNJuyJEYmNFUCYCdBiHlbLycPR7P2OsuDNvjsUxwPV6eNYMafZMoKmSzKm/QLq+SPGKXRqnbbzQM9Oz0UbLP3u70Ifvcx3rt8+xlgueZJh3Dli8x0kouZe97MW2XkSnU2csX0qSpodGQjqbgaDrOHEbR2JSivdm0aVxdjX1NTKu1k21n1b0cGHtder+57OG0nXZ7ubbBHE/EzgiM/Tpj73x+0C6rFSeJQd7UzyjFw3rdsXJLNKQ5+uuTNd7ziiGvces1xyAZp09AIiISCU1AIiISCU1AIiISCU1AIiISCU1AIiISiYpNwaHrIOCVRnGKLIVhJNscSXDBhWzIVgjWYWJpPD9jj8cHSdM4kliJDxmvmSUJwLxdJ+p4FctHizW1Y83+SEAI9camJPrtenrxYVLvr9tuJOgNkAaD2TIUvWPN5OJGqi9h732xljRNa7TH8zVhitvZw6zxHEtwWem4Yty+fvy0fX6aa+zzMKP2iDk+r2ZfYOyNqd+byw44+22qu1BrjheNONmBAVJPrse+DotJVpPPHIazFmenkgXSxrK2GxM2AVpm+gQkIiKR0AQkIiKR0AQkIiKR0AQkIiKR0AQkIiKRqNgUXKF/EJ536tp3eiyB4hlzdMjOmiztxmpzmcuzboljmWIxEoAA7yrLtiRmJBJrSIdXlurzaG0/kg60tp3Vxwv7Y5iRgium7VRblqTdhifacapcrX0UY8bu+zl7f9h1xXjWakhhMkdqiuUK9v5kyMbEELwmaj373DeQjqDTY3b9uX01nYGxJ9OzzGUPxllC1RyWMtNhFhGRSGgCEhGRSGgCEhGRSGgCEhGRSFRsCOFoyZyQZXNGwwoVHI/VaCphH7Ziyh7P1dmvmauzH+jma4IPdJOk1ItnPBAHeBOrUAV6SKM6VqKHljkyQggeK5XDXrMcjffKxCq7U6yxz3220T4/Q1PYNWG/ZqLPGOu3l2VpEDNsAMAzTqfPsh0Ze3/6hu2SNgeG7aZxB9ONgbEeqzMegOlxe2OmxuyDdWYi2OyuIUFKNsXYQSHNC8llaAc57GXp+Fhey6w01xg0mQtDn4BERCQSmoBERCQSmoBERCQSmoBERCQSmoBERCQSlZuCq2QhEyUeS7eQsiaetZ4ypVjCNKpjSTqrASAAuAL5ecYql0PSVFSYUklseT/kazLGcQlbbokEvlBM2ufHxUZfcokltRjfOJ2xYZLQHLKPd9+AXVrp9+lmc3xnsjUwNjFux/qG3QFzHBgwRw8Upge3L0dKP2Xt/fHy5HiTe9mqXMTOGR8/+XJb9L0mrFOUjtMnIBERiYQmIBERiYQmIBERiYQmIBERiYQmIBERiYRScP/HsXSLUbPMHxgyl41329Gm2oQ9zyf67cOfOhSsW+X32a/phu2mXI40kwuDJeZoOq5C1v1/KwqzMeFWnQ2m+mIDdjIw3W0n74oJe/usmm8AEB8KbqM1BhynmRoLdhmXIdu+YpzUsPPtWnB/KDab4wPZ4L2yZ3CCueyklJ12m5iwx3f2tQTGfrNvsrls4oh9D8bt243W0yvGg8eL1YBkteD8PKmDmCVp2bFsRmmtm90nZgJ0dNumT0AiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhKJ0y8Fx7p2sppiRt0zN2RHZFjuI5G3E2nxpJ2as1J2rn+QbF/WHi9DCq5srPQM63zqk9pco0zV/PEfGOuh9eTIOEv9GLXt/EE7BZc8Qq4r1jw2bS/v54Pb4hXs7eMJNns8btQmc7RTKElkFe20Xz5jp+MO9wev/SNH6s1lfbItvm8fxNxAcN2Jl+17LXmEHBNyu7E6e2GShF7RPsexYXLuw9SIG8Mabh65N81lR/nZRp+AREQkEpqAREQkEpqAREQkEqEmoI6ODlxwwQVoaGjA1KlTsWzZMuzcubNkmeHhYaxcuRKTJk1CfX092tvb0dXVVdaNFhGR8S/UBLR161asXLkS27dvx2OPPYZcLod3vOMdGBj4Y0mMG2+8ET/4wQ+wceNGbN26Ffv27cPy5cvLvuEiIjK+eS5Mi8xjHDx4EFOnTsXWrVvxlre8BT09PZgyZQoefPBB/MVf/AUA4H//938xb948bNu2DRdddNGrrrO3txdNTU14m7cMcY+0jRwLJAXnxYLpHi9hhwc9kmrz0qQbY9xej8sYybZMuJpvLm90IQXsjo4sHUaErkFlpWdYmoocW3asvJSdskIqGRhybN3kGHoFktSzUknGdQIALm1fE4W64PYBQDEZomsrq+1Gag+yVFauNrh8vobUfKu1XzNfa6+7QC79gnHaCimWvLOH2XgsWEoRid5waTcrdQjwFFy+Jrj+PDlWqW573bUH7JWnD9r3frx39DUjKfL276z7J0XuH+P+zhcy+PGzf4+enh40NjbSlz+pZ0A9PT0AgIkTJwIAduzYgVwuhyVLlowsM3fuXMycORPbtm07mZcSEZEqc8J/B1QsFnHDDTfg4osvxjnnnAMA6OzsRDKZRHNzc8myLS0t6OzsNNeTyWSQ+ZOf7nt7e090k0REZBw54U9AK1euxPPPP48NGzac1AZ0dHSgqalp5GvGjBkntT4RERkfTmgCWrVqFX74wx/iJz/5Cc4444yR8dbWVmSzWXR3d5cs39XVhdbWVnNda9asQU9Pz8jX3r17T2STRERknAn1KzjnHK6//nps2rQJW7ZswezZs0u+v3DhQiQSCWzevBnt7e0AgJ07d2LPnj1oa2sz15lKpZBiD5JPJVKix1nPp9myRokWAPBI0zjz4TxglqmhWRHSSG/cIg/zvYT9MN/V2NeOqws+/S7WkNJHQ3YZHQyRMkfG+fGMxoUAaMAhniPhEdLwzSWCx8UMQwDw2MNiUgLGOirsYbuftx/mx8glXrSzFmZZIFYqiG0Law7n54LfiA2Tcj6knFGBlTMi+5Mzqghlm8OVM0r02+PJFAmmhCiNw64Vto5iQ/D+yTfYO19IGiGE/Oi2LdQEtHLlSjz44IP43ve+h4aGhpHnOk1NTaipqUFTUxOuueYarF69GhMnTkRjYyOuv/56tLW1jSoBJyIip49QE9C6desAAG9729tKxtevX48PfvCDAIA777wTvu+jvb0dmUwGS5cuxT333FOWjRURkeoR+ldwryadTmPt2rVYu3btCW+UiIhUP9WCExGRSGgCEhGRSJx+DenKwNHkGWkCx5rghcEa5oUVsuzOKeeTxE/aTrsVG+x6J9lJRoqn3l53stu+DRKsXJCVjiNlezzSjJBdQZ4jt6SxLSzZ5IwGcwAv0eOMa4Klw8ACnazyk1EWB7Ab3lnbAQAubC9CY9M9ds+yJB3ZH5bIS/aZS5vLJsjf2ieGSFIvQ95X8iHeV0gZKpe0xzOTawJjAy32sla5pUJ2dA0x9QlIREQioQlIREQioQlIREQioQlIREQioQlIREQioRTcq7ESbCETaSw154VJpLEkHduWSk+7EaypH6v5lm+2x4emBteTabSPSS1Jjfk5+5jHwtSCI3+8TZvd+SGSTeQcs5pqBdJkzuKRFFwsw/J74WoSOiOQSFNwJBhZJOfNWp4ty34Et+rJAUCMjWeD60+SJniJAfscpw7b11BswB43rznWYM6oJQjwxoiDU4JTQ/9Me3/ydcHXZOnHY+kTkIiIREITkIiIREITkIiIREITkIiIREITkIiIREIpuEpkJNs81tGQdhAd/al1JJHFunlSRjpszIUIZbEOmmycJYpg7SZblh1bhq3HqAVXJN1TWc27TKO9vJ8PvmZi0N4Mlgy01gEAHhl3RlKPpeDyJL3n7MAk8qngeqx6Zcdj13YD/EF7f+JDRjKS3D7xIbvQXKzX7sDrD9oF+DyrAzNNXYarhedZ6wlblG8U9AlIREQioQlIREQioQlIREQioQlIREQioQlIREQioRRcBbISbKxGmpcm8Z4aMm4l1YZJm8uMPU5Tc2VIwTlSU80bsrclQbqZWvXdkv2sIyqpwdVL0kfW8SKdT0On40LU8iqkSdqtwR4fmmynmOJDwXFWqy5GLhWWdouRbp7FYvBnX1bDrkjqmGUb7OWzRs2/vN04lycjyelk6bjYcPB4xUkNN3/QTrt5wyFqvgH2Nceut4z9mrE+Uh/xQPD9xnn2e5DdEdXejGPpE5CIiERCE5CIiERCE5CIiERCE5CIiERCIYQTEbY5HEOW9+LGaUnZjddcQ505XmyssddtlOTwe0nHL6P8CwD6QNOxEIIforQQQx7E+r12zZiksS2JpH2504fCJPgAqwRK3i6vQrESSqR5ocWRUjwF+1JBwb4k4BmnjTWBY6VbaImejH1cnGcEbcgxKZCSOzkSQsg1BjfSapoGAF7eXkfqMGlSyMIWRnmd2BH72gwVKgD4tWUEDhwrxTNs749HXjPVFVw+NmQHm4rJ4HWYz48uhaBPQCIiEglNQCIiEglNQCIiEglNQCIiEglNQCIiEgml4E4BjzTaAhs3Em9enV1LJDe5wRzPTLajUFbJlDRJU7EgFEsrsf3xksngYJpEtcKWrrESaQD8viFjQ8jxJutg6SMz7RcivQYAtLUXaQLoDQWTU4le+7zVvkzWTqJtiaHgtqe67e1I9JKyRcP2sfJyJNmVDr71FBOkwV6aNKoj5XWs3YwNkjJEZDzVY19viV7STG4weFzMhnFAWdJuwHFKYlnL5kiZH3K9+T3BsUSWbJ+Rco0VSIL02H86qqVERETKTBOQiIhEQhOQiIhEQhOQiIhEQhOQiIhEonJTcM4hUHiKpZjGKY/sj5cKpsaK9XYdpuxEI2EGoH+anXiyGor5OTuRliKpF5bqY2fH1Qa33dXZ+8NSU97gsL1y0kzPmU3jQtZrC4MlGsk5diQIxeqE+cb+eyQdlSaBvPigXVTNquMWY83USG03mnYLgTWkK5AUXI7Ud7Mk++11pA/Z60h12wmzeB9pUjhojJcjXQnwhKVVk5KlSEkNO3oErfunh3Tjs679omrBiYhIBdMEJCIikdAEJCIikdAEJCIikdAEJCIikajcFJyFJTwqPB3naIqFJFOMuk1mygZAsttOk9Wm7J8t/GzwNRO9pCMoSTxZtZ8AO+0GAPkpwXp1mYl28i4+aKepkofI/pijAAaNWnCk7lVoZuqHbAndQDvx5IokYWik49hVHyfXlc9SjUaXXI/V/WJ1zEJ0wwWAWCa4ntiwve74IKlhN0AShsZw3Lgcjm6HPc46vCLPkmpWfUB2jsuQdgPs94+w6whZw9BknTY3usSpPgGJiEgkNAGJiEgkNAGJiEgkQk1A69atw/z589HY2IjGxka0tbXh4YcfHvn+8PAwVq5ciUmTJqG+vh7t7e3o6uoq+0aLiMj4FyqEcMYZZ+D222/HnDlz4JzDAw88gCuvvBJPP/003vCGN+DGG2/Ej370I2zcuBFNTU1YtWoVli9fjscff3ystn98Yw8Ah4yyKyRoESfN4WpZSRujiZXfaz+hZQ21nFEqCACKpLyOFTgYIKWCkn0kbFCw182aZFkP7YssxBKSZz3P9clDXpZ78ML98sHaco+UdGHlfGLkYb79guRYhX1oHbdf0wo5xIZJ2GDQfs1EHwkhGIc2bjTdA4CYEcoBAD9nj7MGbtZ9RUMv7BgWQy5vCRk2cGHuCRaeMNc7usBPqAnoiiuuKPn/L3zhC1i3bh22b9+OM844A/fddx8efPBBXHrppQCA9evXY968edi+fTsuuuiiMC8lIiJV7oSfARUKBWzYsAEDAwNoa2vDjh07kMvlsGTJkpFl5s6di5kzZ2Lbtm10PZlMBr29vSVfIiJS/UJPQM899xzq6+uRSqVw7bXXYtOmTTj77LPR2dmJZDKJ5ubmkuVbWlrQ2dlJ19fR0YGmpqaRrxkzZoTeCRERGX9CT0Cvf/3r8cwzz+CJJ57AddddhxUrVuCFF1444Q1Ys2YNenp6Rr727t17wusSEZHxI3QlhGQyide+9rUAgIULF+LJJ5/EV77yFVx11VXIZrPo7u4u+RTU1dWF1tZWur5UKoVUyv6reBERqV4nXYqnWCwik8lg4cKFSCQS2Lx5M9rb2wEAO3fuxJ49e9DW1hZ+xZ5X8SV2ThpJrDgr3TRsN2Sj6TjWDMtKsrCmbiQhQxvpJezLyWx4RhJPLJXksdIoVvoIKF/ZHYN1XMxk3PGETc0Zr+nY/cGOSY6ctzD3WbnuSav8D6siQ35PU7T765njjjUMJK+Z6iXlphIk1ZcJrp8mzMKm3ViyLcQ6QqXdgFCJNzMxOcrXCzUBrVmzBpdffjlmzpyJvr4+PPjgg9iyZQseffRRNDU14ZprrsHq1asxceJENDY24vrrr0dbW5sScCIiEhBqAjpw4AD+5m/+Bvv370dTUxPmz5+PRx99FG9/+9sBAHfeeSd830d7ezsymQyWLl2Ke+65Z0w2XERExrdQE9B999133O+n02msXbsWa9euPamNEhGR6qdacCIiEglNQCIiEonx1ZAuDFZrK0yiJOy6y8RZCa5hkpgjiSePJNvMdbCaYiTxxPItPkm+pA4Ek0N+ntTmGrK3Jd5N6tUNkQQf2SdTmMQPYDZZC5sYpIknlo4zG96xdbA0VYjzGfYaJykzj6WhjNWzpFq+xh7PNtvrztcaCbs8WXetPZ4gdfNSh+w6iLR5o2UMm8bx5F3Ia7xMdRNfjT4BiYhIJDQBiYhIJDQBiYhIJDQBiYhIJDQBiYhIJCo2BefFYvC8UXZwNLqCeqRTqJkwA8pTh4m8Jk1CkeWtOmY03cLquGH0KTiGpZLYTy3s2Fp76Wfsrp3Ik46TJO2GHFmPkeLykqR4WMhrIkxdrbA1uHhNOWMbWX2zcnRhZUk6muoj66YdRK16eiRJyI5JmEahMXIuyTsgu/Zp/T1L2O6xIZc3r62xTLuFqg83umX1CUhERCKhCUhERCKhCUhERCKhCUhERCKhCUhERCJRuSm4VBKeV1p3iSXbUJMO/vuEnXhymay9jky4rqAWL24fTi9l148C20Yj2eax7SM1zxzriBqquyLpCpklx5AdK6uDKDsPYbHkYdpo827UcAMAZO0knWNdaI36e7T2HEsOkW0Jdb2VqwurhaXaQtafc+SwWKnGWMxOmNV22fdJMWbfb4Uaq9CcvR3xIfsbtQdITcJeck0Y17NjnU9D1qMM3c3UXkm45cOm6U6QPgGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkKjiEkILnHxNCYA/tG+oCY8Va4yE0AL/PbmzGSm94rEyLtWzKfk1XX2uPp+zD7/cHx9kjRFYYhIYQwiAPS12ePKAkzfGs0ILnDZrLekkS2CDH1quzly8ax9yl7MCC328HPFgzNWcFQsIe7jFsgseECy2Q6z5s+R9mKPgw3yfHpIYENuLDwfARABSSo/+5OpaxXzNxhDRA7LevW1ihmrBlv9h7EDlvZQknlCFsYG3HaDdNn4BERCQSmoBERCQSmoBERCQSmoBERCQSmoBERCQSlZuCa6iD55cmnxwpaZObUh8Yyzbby6YO2+Pxg/Zc7JEGaRZXa6dyslOCKT0AyNfZqazUoeA2shNF03GkXA5NsJUDKzFilHVx5EcfL0HKGZFjW2yyj212cjAFl6tnx9tOV5L2dXbykJVECpGiPK4waaWQZX5ow0RzO8Imr+z9d0YjQZY69Hvt/UnmyLrjo/+52iP3gzdol9yxymQBsI9Lwn6v8eKkpBhrmMiOuXWPs7JSYUtFWesoR+ruGPoEJCIikdAEJCIikdAEJCIikdAEJCIikdAEJCIikajYFFyxrhbFWGkKrlhrp0SGpwbrhA1OIUmgmF1TrDZjp0S8jJG0IdN2vtFOag1NtdMwmcbRp4/8oRp7nNR8c4OkZhVLw1jrIOkbj9UDKwffTgg5q8EcgHyzfcwHpwavlSw93vb5iQ3ZrxmzjvmgXTusbKwEUpj02nFXXf500yto/TnjOnSkliCMxBwAoI80IxzFdv3xRUn9QrYtLNVoJNhY7UqrgSYAFEnSk/EHgtccTcWy/SSHdiyviT+lT0AiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhKJik3BeZksvFhpnoWUuEKiP5hMSSXtLEyiz06x+MMkHRais2gsYadyEv2sqpi9fHwguI3eMImrsIRQiBQLS7uFXZ6m46wEjlEf7ui4fX48UuMqNmifn2Sfdczt17SuHyDkNRG25hurwcUu8ljwWvHi5PYlNcXo8sa2WLXajn6jPOkoMyHGUmOszh6r02hdQ+T80LRbSL51bElyszDBrl+YI4lOJnE4eE3EWBdfdo+T2nZWfUDVghMRkaqhCUhERCKhCUhERCKhCUhERCJRuSGE/kF4funDR/YgOmU8MIsN2g8A4912oymvd8DekBCla8wSLQDS5DlnssY+/PGe4DZ6/XZpHZchjefYQ9fQDcVGL1Q4gZUGIeeYlbrxu+0gh1W4KNlDjncvuSbYMTce3NLGc2EayQG0vI4VIPBIg0ZW6oU1TLRCFd4QabzGwgmMEZ4AAFcTvD9ZuSWPXONsG92wcT7ZdR/2/NAkVDBAwY43CxsMtLKwkq3O2CU/Y58fj5XsYvtjHJcwjQtHu6Q+AYmISCQ0AYmISCQ0AYmISCQ0AYmISCROagK6/fbb4XkebrjhhpGx4eFhrFy5EpMmTUJ9fT3a29vR1dV1stspIiJV5oRTcE8++SS+/vWvY/78+SXjN954I370ox9h48aNaGpqwqpVq7B8+XI8/vjjodbvhobgvGOSRSSB4xvlNBIDdkKIJmdYQ7EwJVbI9sVIyRA/RUqmWI2mhuzto6mxsKVhKgVLWQ2Fa75mHXM/YV/u9JogxxzWMWepQ1K+hCaKSCrJSry5+lpz2cLkBnM8M4EkQ4eC2544bCcAvUFSuoWkzFzM3p9iU3Dbc01k+8yySkCMJQaNY05L7oRIuQLgqbmxbOpXjlWz642kFD2rnBMr5eQFz7FXzAJ2uLTECX0C6u/vx9VXX41vfvObmDBhwsh4T08P7rvvPnz5y1/GpZdeioULF2L9+vX42c9+hu3bt5/IS4mISJU6oQlo5cqVeNe73oUlS5aUjO/YsQO5XK5kfO7cuZg5cya2bdtmriuTyaC3t7fkS0REql/oX8Ft2LABv/jFL/Dkk08GvtfZ2YlkMonm5uaS8ZaWFnR2dprr6+jowOc+97mwmyEiIuNcqE9Ae/fuxcc//nF85zvfQTodrnQ4s2bNGvT09Ix87d27tyzrFRGRyhZqAtqxYwcOHDiA888/H/F4HPF4HFu3bsXdd9+NeDyOlpYWZLNZdHd3l/y7rq4utLa2mutMpVJobGws+RIRkeoX6ldwl112GZ577rmSsQ996EOYO3cuPvWpT2HGjBlIJBLYvHkz2tvbAQA7d+7Enj170NbWFmrDXDYLd2xwgyVWrDpHQ/auFVlqjKSvwjRh8tj2sdckCZSitR62fSTdM5Y138KytoU1r6NppaxdD4ymj6xj6JO6ZKzhWYjXLFezLo+kxqzEW2Fivbls/wyrEh7QP93e/2Rv8F5pSNrbkTxMkoR5ch3G7PM8PCW4jUNT7HXXHLK3JU2ucTN1miG17ZiQDQOtmoxWmhUAkofs84CQl1DycHD93iCJnpGUppl2A+DVBq8312CnLl08eExcIQO8bG/Knwo1ATU0NOCcc84pGaurq8OkSZNGxq+55hqsXr0aEydORGNjI66//nq0tbXhoosuCvNSIiJS5cpeDfvOO++E7/tob29HJpPB0qVLcc8995T7ZUREZJw76Qloy5YtJf+fTqexdu1arF279mRXLSIiVUy14EREJBKagEREJBIV2xEVvh+sMUSSKUUr4TJIulmydBjp0BkGDbEYtZLCr/zkty+0cmw3wVN6pIYd23+WYDO6llYUkg5jyUgYteDyDXa9w6HJ9nkbfI19zPO1wW1JDthvDX7Wfk0/Q84b2c18XXAbs432wrEMSe91k22MG8uzazlsR1S2vPEe5Mg165PEZIp0M2WsxBu77lntQS9pn8/ihGDCMjeJ1B5MBY93PpcAnjcXL6FPQCIiEglNQCIiEglNQCIiEglNQCIiEglNQCIiEomKTcH5LVPg+8d0SGRdJ600yMCAvWKrbhwAR2pZlUUUCbZyYNs9huk4hqXmWE25ijnm5FjRTqnleM2QNcXMjpts+8h9EhuyE1xezr5n08lgcsojpyx1hHQa7rHrnlkdbmm9v3J1MjXWz86lA+k2y2pGsvVY9SFZLcU6Usetxu5Cm5laFxjrm2kn5qwUZSFbAP7T3pQ/pU9AIiISCU1AIiISCU1AIiISCU1AIiISiYoNIeSmNsLFS9t++1n7gWbssFF6gzWHIxwJOKBIxsuBlMeoeGEf8EdS0sfajHFwvGmpqDI8LGerCLFqr0DCCaSMjNdPmrIZJW3i/fYDcX+AlJfpI+W2hoKvSZsLMiEbOrpi8P2GvqeQ5nisXE4opJST12g3L3R1aXN8aGqwUV3/THv7cg3Bc1kcHt17hD4BiYhIJDQBiYhIJDQBiYhIJDQBiYhIJDQBiYhIJCo2Bdfz/2oRS5YmNBJDdjKlzijrkSAldxiPpGScM5If5SrfEWY94zUxB9ipuQoq5xNWqDQdSwwWSYkekt70jXJTicPBpBIA1O8nTe1gj6d6g9tYe8C+H+I9dqqNpd2sRBoAeEYKLjZMkmqkRI0btkvxOGt5mnIt071chnW7sDWUDJ5P7quMfWy9QTuRlz4cPF61++zr3mouWMiM7v7WJyAREYmEJiAREYmEJiAREYmEJiAREYmEJiAREYlExabges/0EEuXpi4S/XYKw88F6xnFj9SYy3pWEycA6Gdz8RjWgguDJebGazqugprdhVWW+nNs/8n16fqDDRZj5JqoI+PJHrvuV2w4mLyLHbYbOnp99rgbttNUjtQ9c0PBBJtH6pjRmmqsQaW1/7TGXoU0LiwTdqxYYpDVn0vvDzaf84rBJnUAUEgG79n8KFPIlX+3i4hIVdIEJCIikdAEJCIikdAEJCIikdAEJCIikajYFFx8GIgdE1yJ22WlEMsaSZaCnW4xEzLj2emSjmMqPDXHEnMsHefIdQsjNcaucZ+MJwdIEspILFkpteOOkxp2LkRNRgeSUA2rypJtoZDrzayPdxz+4eDUkM6RhF0imF7MF+z0Y+B1Qm2ViIhImWgCEhGRSGgCEhGRSGgCEhGRSFRsCKFxdwHxROlDrzhpSJfuHAyM0ZIh7CEqK/cxXkML1RZOYMZpSR8eTiDhGeshPzvH7FomzeGsa5+GB1ipFxaeOJ0DAVEgx5ueT6Mx4NFx49pizQWNEkpekTQXPEZl36UiIlK1NAGJiEgkNAGJiEgkNAGJiEgkNAGJiEgkKjYF1/DbAcRjpckNj5SC8HuCiTc3EEzGAYDLknTG6ZLWsZJT1ZaMA8KdzwpKzNF0nNEYkTYfY9c4288xvPbDNO8bz8zSSuR4ezFyHkhDPspKL4ZMIxaz9jXkWalL+y3VXq8bXemfyrnzRETktKIJSEREIqEJSEREIqEJSEREIhFqAvrsZz8Lz/NKvubOnTvy/eHhYaxcuRKTJk1CfX092tvb0dXVVfaNFhGR8S90Cu4Nb3gD/vM///OPK4j/cRU33ngjfvSjH2Hjxo1oamrCqlWrsHz5cjz++OOhNyzWdQQxP1U6yFI/w8H6bsUMaYhUbTXfyuF0qRvHVFkTPKoMabfTJdXGsEaCXtx4K00k7GVTSTKeMscZZ73HhWwYiCJpJHiS53m0jT9DT0DxeBytra2B8Z6eHtx333148MEHcemllwIA1q9fj3nz5mH79u246KKLwr6UiIhUsdA/yu3atQvTp0/HWWedhauvvhp79uwBAOzYsQO5XA5LliwZWXbu3LmYOXMmtm3bRteXyWTQ29tb8iUiItUv1AS0ePFi3H///XjkkUewbt067N69G29+85vR19eHzs5OJJNJNDc3l/yblpYWdHZ20nV2dHSgqalp5GvGjBkntCMiIjK+hPoV3OWXXz7y3/Pnz8fixYsxa9YsfPe730VNTc0JbcCaNWuwevXqkf/v7e3VJCQicho4qaepzc3NeN3rXocXX3wRra2tyGaz6O7uLlmmq6vLfGb0ilQqhcbGxpIvERGpfidVC66/vx8vvfQS/vqv/xoLFy5EIpHA5s2b0d7eDgDYuXMn9uzZg7a2ttDrzu/vAjw7RTIqp3OqrVzCHkOl5oJCJuZYyqosyTvWLfM0T7aVhdUVNElScHW15rirt8cZr9+oHcfuWTscxzulmguHuO5HuWyoCegTn/gErrjiCsyaNQv79u3DLbfcglgshve///1oamrCNddcg9WrV2PixIlobGzE9ddfj7a2NiXgREQkINQE9Pvf/x7vf//7cejQIUyZMgWXXHIJtm/fjilTpgAA7rzzTvi+j/b2dmQyGSxduhT33HPPmGy4iIiMb54b7V8MnSK9vb1oamrC27xliOtXcOPL6fIruDD0K7iqQv8Q1fgjUi9t/2GpV19njof/FVywP4LrD7amAQA3bP9hfpH84aq9ktH/Ci7vctjiHkJPT89xn+uP0z/pFhGR8U4TkIiIRKJiO6Ka9Gu1ynY615Sj3S/tLpesK6aXtOuEwUhUeaTWGOuI6rJ2l0ovFxxntcP06zqbdd7Yr9oKE+1fSWWnhPtbyuTB4Nt3jJ0f1mmX1Mw8VedZn4BERCQSmoBERCQSmoBERCQSmoBERCQSlRtCcA6AHnhWhTDhkWoLLLC/G2Fhg5q0vbxRvsXVkL8zGRiy183+RsQaLLC/+SANHSsd+xuWsH9fxcImRpM5V2ufy9xEe3ygJdzfPXqF4Jnzh+0AihU0AQD0hXrJstMnIBERiYQmIBERiYQmIBERiYQmIBERiYQmIBERiUTlpuDk9DQOyvlY5XW8uH0rsXIsXmODOV5ospfPNwUTb/lau8xP6mU7YRenx7A/OERSU64wDlJw5WicxtJxrKK4UbrIy9jHMDZolzlK9od7O7bWw16TlVaiwhzDk6BPQCIiEglNQCIiEglNQCIiEglNQCIiEglNQCIiEonqTcGxxE8UTe3KkeA63Zvxhd3/sUzNWSk4UtvNa6g3x3OtTeZ4ZpJd3224OfiaOXvVqE/Yjc3qsnaCzc8Hx13GrikG0tTudMEatVnHyxu0a/LFD9tvu7Uhr/HY4WBtPzcwaC7LzmfUDQb1CUhERCKhCUhERCKhCUhERCKhCUhERCKhCUhERCJRuSk4PwZ4pckfj3WXtOpwGUkl4Dg1kcpR44p1S4yReT7MNpLtoymW4jio2TWWrERRmZJx5vVGOpkWG4OdTAEgM9FOuw1Nsq+JvBFsK6Ts/SnG7XFXhv1n9yBFrnGrnh5bll777J41xul9wmqeha0RZ70mSZ55g8PmeIy9TxDeUCb4miylOJY1/Kx7bZSJPn0CEhGRSGgCEhGRSGgCEhGRSGgCEhGRSGgCEhGRSFRsCs6vScH3SutrmckZwEwgsdpcbjiYHDk6bidTUBx9Z0AvQbpipu2EFBIJe1uGgjWk3BDZPpLqc1mW7jmNa8qF7bbKUo3GteWRFFyuwU67ZZrsdefq7G3xc8FtT3Xb+5Pssa8Jv9+uTWbeE6QjKj0m7NpnnWJrjVhf2j5WCHnPmkmwLKmFdpqHRcN1jy3/e4c+AYmISCQ0AYmISCQ0AYmISCQ0AYmISCQqNoTgpdPw/GNCCOyhfUNdYKxQZz8UZg9ivV7yIDpECQsvZT9EdY3B7QMAl7L3x+8NcVpIOMHlSMmh0/6paxkYJVNc0j6XxaQdnCkkSbkckrOJ9wXH0kfsc5nsth/ae/12s7Ki8TDfFcjD6TDlsEDCBgBcY7CbXrHRXtbvs69xGkqC0agtRNmeE2IFWVhpnTgpwZVg+0Ne0loPe82xbNB4EvQJSEREIqEJSEREIqEJSEREIqEJSEREIqEJSEREIlG5KbiGOnh+aarMpe3yOrmpwURNZoKdSkoftMfjJCXisTSZoVhnp3hyU+ymZLk6+/CnXw6Ox0OWwfBIYyp3ujeqC4OVKTGOrTdgpyuTh+xrtj5hX2+FGvtnwkRv8Lwlekhjs8P95rgbsFNwZtkdsu9ezN4f1pDPSrsBQG5qQ2BseIqdIk0dsV8z2UXuWaN8FruPaVo0JLM8U5193xcm2sdkeKq9PJOOB6+VGCsdxlKNrMRXmBI9J0GfgEREJBKagEREJBKagEREJBKhJ6A//OEP+MAHPoBJkyahpqYG5557Lp566qmR7zvncPPNN2PatGmoqanBkiVLsGvXrrJutIiIjH+hJqAjR47g4osvRiKRwMMPP4wXXngBX/rSlzBhwoSRZe644w7cfffduPfee/HEE0+grq4OS5cuxTDrtyMiIqelUCm4v//7v8eMGTOwfv36kbHZs2eP/LdzDnfddRc+85nP4MorrwQAfOtb30JLSwseeughvO997xv1axVra1CMlaZiivV2GmZoSnB8cAqbW+111GbsBJs3bKRkyKrzjXYSaLDFfs1MI0nxuGAayB8kdbJIisfrD9bDAgCXN17zdG5SB4RuVOes5mYD9vH2yTpqsiSVReqb+UbKzoWo7QbYjQ4BwBVHf/5Z/TWPNJMrkPpuVuKtf5q97iJ5l4oN2+uODwfPj0f2HWSY8UgtPBi1AF2t/X6QnUDeJ6aGCyX7ueB60oN24z3W1I/tz6kqGRnqE9D3v/99LFq0CO9973sxdepUnHfeefjmN7858v3du3ejs7MTS5YsGRlramrC4sWLsW3btvJttYiIjHuhJqDf/OY3WLduHebMmYNHH30U1113HT72sY/hgQceAAB0dnYCAFpaWkr+XUtLy8j3jpXJZNDb21vyJSIi1S/UZ75isYhFixbhtttuAwCcd955eP7553HvvfdixYoVJ7QBHR0d+NznPndC/1ZERMavUJ+Apk2bhrPPPrtkbN68edizZw8AoLW1FQDQ1dVVskxXV9fI9461Zs0a9PT0jHzt3bs3zCaJiMg4FWoCuvjii7Fz586SsV//+teYNWsWgKOBhNbWVmzevHnk+729vXjiiSfQ1tZmrjOVSqGxsbHkS0REql+oX8HdeOONeNOb3oTbbrsNf/mXf4mf//zn+MY3voFvfOMbAADP83DDDTfg85//PObMmYPZs2fjpptuwvTp07Fs2bJQG+YPDcP3S9M5HkkrpQ5b9d3sXUsdsWuk0a6LIWpFsXpy6cP2tsQyduon2W3UGhu0UywuY6deaEfL0z3xFgY5Vi5vXBMh/8rAs9YBnjJzmeD5d6wbLlk3TbuFqfvFOoiS65DdV1Z9N5Z2Sx+29yfWZ98TVq0+3iE4XM0zV2QR2OD6vSF7+5I99rGqSYfriGqth72mo7Uho30/CDUBXXDBBdi0aRPWrFmDW2+9FbNnz8Zdd92Fq6++emSZT37ykxgYGMBHP/pRdHd345JLLsEjjzyCdNqOHoqIyOkpdDXsd7/73Xj3u99Nv+95Hm699VbceuutJ7VhIiJS3VQLTkREIqEJSEREIlGxDencwBCcX/rAkzVZs4qAxAft0iCxHrv2htdLmnixBk8GnzygTZGH2Ym03Rwv1m2UWOkjpXVYjb1T1FDqdOSM88we5nohG4F5rPyPtR5yjssSNiDYw3x2HbJQRfJA8Gdfn5TDYmEDr4fcs4NG2SISzAiNHXOr1I1PyirF7fGaEO81AOD3BN8nHCvBZZWPAvg1cYrCSvoEJCIikdAEJCIikdAEJCIikdAEJCIikdAEJCIikajYFBxyuUBDMJbLsMpPsEZgntGsCgBczk7YgaWYzJWT1xwiabcCSU4ZZU1oiock76IusVHVrIQQ6eDlwpZ6OZHtCb7oya+DXMs0BcbuE5Jcte7DWNz+edgjzdTYPWveK2N9P1j3ISu3RN6D/ES4t2NrPWHfJ6KmT0AiIhIJTUAiIhIJTUAiIhIJTUAiIhKJigshuP97gJp3xoM6Vu6kGCxtUSzYD1H9InmgWQxZqsLcDrKKAjnM5MGtZ2wj2z5nHScARUdCFeRhuYwV8jB/LJWljAoJ1JD7wXN2eRmP9M/xjOY/7J71CqTvT4h7wpH7gY2H5bvgtvNjQno+FcL1AzLfJ8j7Qfj3iZO7hvLI/d9qjr8ez73aEqfY73//e8yYMSPqzRARkZO0d+9enHHGGfT7FTcBFYtF7Nu3Dw0NDejr68OMGTOwd+/eqm7V3dvbq/2sEqfDPgLaz2pT7v10zqGvrw/Tp0+H7/MnPRX3Kzjf90dmzFcqAzc2Nlb1yX+F9rN6nA77CGg/q00597OpqelVl1EIQUREIqEJSEREIlHRE1AqlcItt9yCVMpuLlcttJ/V43TYR0D7WW2i2s+KCyGIiMjpoaI/AYmISPXSBCQiIpHQBCQiIpHQBCQiIpGo6Alo7dq1OPPMM5FOp7F48WL8/Oc/j3qTTspPf/pTXHHFFZg+fTo8z8NDDz1U8n3nHG6++WZMmzYNNTU1WLJkCXbt2hXNxp6gjo4OXHDBBWhoaMDUqVOxbNky7Ny5s2SZ4eFhrFy5EpMmTUJ9fT3a29vR1dUV0RafmHXr1mH+/Pkjf7jX1taGhx9+eOT71bCPx7r99tvheR5uuOGGkbFq2M/Pfvaz8Dyv5Gvu3Lkj36+GfXzFH/7wB3zgAx/ApEmTUFNTg3PPPRdPPfXUyPdP9XtQxU5A//Iv/4LVq1fjlltuwS9+8QssWLAAS5cuxYEDB6LetBM2MDCABQsWYO3ateb377jjDtx9992499578cQTT6Curg5Lly7F8PDwKd7SE7d161asXLkS27dvx2OPPYZcLod3vOMdGBgYGFnmxhtvxA9+8ANs3LgRW7duxb59+7B8+fIItzq8M844A7fffjt27NiBp556CpdeeimuvPJK/PKXvwRQHfv4p5588kl8/etfx/z580vGq2U/3/CGN2D//v0jX//93/898r1q2ccjR47g4osvRiKRwMMPP4wXXngBX/rSlzBhwoSRZU75e5CrUBdeeKFbuXLlyP8XCgU3ffp019HREeFWlQ8At2nTppH/LxaLrrW11X3xi18cGevu7napVMr98z//cwRbWB4HDhxwANzWrVudc0f3KZFIuI0bN44s86tf/coBcNu2bYtqM8tiwoQJ7h//8R+rbh/7+vrcnDlz3GOPPebe+ta3uo9//OPOueo5l7fccotbsGCB+b1q2UfnnPvUpz7lLrnkEvr9KN6DKvITUDabxY4dO7BkyZKRMd/3sWTJEmzbti3CLRs7u3fvRmdnZ8k+NzU1YfHixeN6n3t6egAAEydOBADs2LEDuVyuZD/nzp2LmTNnjtv9LBQK2LBhAwYGBtDW1lZ1+7hy5Uq8613vKtkfoLrO5a5duzB9+nScddZZuPrqq7Fnzx4A1bWP3//+97Fo0SK8973vxdSpU3Heeefhm9/85sj3o3gPqsgJ6OWXX0ahUEBLS0vJeEtLCzo7OyPaqrH1yn5V0z4Xi0XccMMNuPjii3HOOecAOLqfyWQSzc3NJcuOx/187rnnUF9fj1QqhWuvvRabNm3C2WefXVX7uGHDBvziF79AR0dH4HvVsp+LFy/G/fffj0ceeQTr1q3D7t278eY3vxl9fX1Vs48A8Jvf/Abr1q3DnDlz8Oijj+K6667Dxz72MTzwwAMAonkPqrhq2FI9Vq5cieeff77k9+nV5PWvfz2eeeYZ9PT04F//9V+xYsUKbN26NerNKpu9e/fi4x//OB577DGk0+moN2fMXH755SP/PX/+fCxevBizZs3Cd7/7XdTU1ES4ZeVVLBaxaNEi3HbbbQCA8847D88//zzuvfderFixIpJtqshPQJMnT0YsFgskTbq6utDa2hrRVo2tV/arWvZ51apV+OEPf4if/OQnJQ2pWltbkc1m0d3dXbL8eNzPZDKJ1772tVi4cCE6OjqwYMECfOUrX6mafdyxYwcOHDiA888/H/F4HPF4HFu3bsXdd9+NeDyOlpaWqtjPYzU3N+N1r3sdXnzxxao5lwAwbdo0nH322SVj8+bNG/l1YxTvQRU5ASWTSSxcuBCbN28eGSsWi9i8eTPa2toi3LKxM3v2bLS2tpbsc29vL5544olxtc/OOaxatQqbNm3Cj3/8Y8yePbvk+wsXLkQikSjZz507d2LPnj3jaj8txWIRmUymavbxsssuw3PPPYdnnnlm5GvRokW4+uqrR/67GvbzWP39/XjppZcwbdq0qjmXAHDxxRcH/iTi17/+NWbNmgUgovegMYk2lMGGDRtcKpVy999/v3vhhRfcRz/6Udfc3Ow6Ozuj3rQT1tfX555++mn39NNPOwDuy1/+snv66afd7373O+ecc7fffrtrbm523/ve99yzzz7rrrzySjd79mw3NDQU8ZaP3nXXXeeamprcli1b3P79+0e+BgcHR5a59tpr3cyZM92Pf/xj99RTT7m2tjbX1tYW4VaH9+lPf9pt3brV7d692z377LPu05/+tPM8z/3Hf/yHc6469tHypyk456pjP//u7/7Obdmyxe3evds9/vjjbsmSJW7y5MnuwIEDzrnq2EfnnPv5z3/u4vG4+8IXvuB27drlvvOd77ja2lr37W9/e2SZU/0eVLETkHPOffWrX3UzZ850yWTSXXjhhW779u1Rb9JJ+clPfuIABL5WrFjhnDsag7zppptcS0uLS6VS7rLLLnM7d+6MdqNDsvYPgFu/fv3IMkNDQ+5v//Zv3YQJE1xtba17z3ve4/bv3x/dRp+AD3/4w27WrFkumUy6KVOmuMsuu2xk8nGuOvbRcuwEVA37edVVV7lp06a5ZDLpXvOa17irrrrKvfjiiyPfr4Z9fMUPfvADd84557hUKuXmzp3rvvGNb5R8/1S/B6kdg4iIRKIinwGJiEj10wQkIiKR0AQkIiKR0AQkIiKR0AQkIiKR0AQkIiKR0AQkIiKR0AQkIiKR0AQkUgYHDx7Eddddh5kzZyKVSqG1tRVLly7F448/DgBmC3aR053aMYiUQXt7O7LZLB544AGcddZZ6OrqwubNm3Ho0KGyvk42m0UymSzrOkWiolI8Iiepu7sbEyZMwJYtW/DWt7418P0zzzwTv/vd70b+f9asWfjtb3+Ll156CatXr8b27dsxMDCAefPmoaOjo6Qj5ZlnnolrrrkGu3btwkMPPYTly5fj/vvvPxW7JTLm9Cs4kZNUX1+P+vp6PPTQQ8hkMoHvP/nkkwCA9evXY//+/SP/39/fjz//8z/H5s2b8fTTT+Od73wnrrjiipH+LK/4h3/4ByxYsABPP/00brrpprHfIZFTRJ+ARMrg3/7t3/CRj3wEQ0NDOP/88/HWt74V73vf+zB//nwAR58Bbdq0CcuWLTvues455xxce+21WLVqFYCjn4DOO+88bNq0aax3QeSU0ycgkTJob2/Hvn378P3vfx/vfOc7sWXLFpx//vnH/XVZf38/PvGJT2DevHlobm5GfX09fvWrXwU+AS1atGiMt14kGpqARMoknU7j7W9/O2666Sb87Gc/wwc/+EHccsstdPlPfOIT2LRpE2677Tb813/9F5555hmce+65yGazJcvV1dWN9aaLREITkMgYOfvsszEwMAAASCQSKBQKJd9//PHH8cEPfhDvec97cO6556K1tRW//e1vI9hSkWhoAhI5SYcOHcKll16Kb3/723j22Wexe/dubNy4EXfccQeuvPJKAEef5WzevBmdnZ04cuQIAGDOnDn493//dzzzzDP4n//5H/zVX/0VisVilLsickppAhI5SfX19Vi8eDHuvPNOvOUtb8E555yDm266CR/5yEfwta99DQDwpS99CY899hhmzJiB8847DwDw5S9/GRMmTMCb3vQmXHHFFVi6dCnOP//8KHdF5JRSCk5ERCKhT0AiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhIJTUAiIhKJ/w8L9BcR+6bc0AAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGzCAYAAABpdMNsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUPFJREFUeJztnX+YVmWd/9/nPL9mmGFmBHUGdHBxpcAfmIHiLNqWUqxbLCZXWWstlrtd6kAi62VxbWp5lVhtahpitgb2g6XYwn64akZJuy6gjlKahZq0UDBDmczAMPP8Ovf3D74+28z5vPG5YfAM4/t1Xc91yf3cc5/71zmfOXO/fX8C55yDEEII8RoTJt0BIYQQr08UgIQQQiSCApAQQohEUAASQgiRCApAQgghEkEBSAghRCIoAAkhhEgEBSAhhBCJoAAkhBAiERSAhBBCJEL6cDW8bNkyfP7zn0dnZydOP/103HHHHTjrrLNe9eeiKMKOHTswevRoBEFwuLonhBDiMOGcw549ezB+/HiE4QHec9xhYPXq1S6bzbqvfvWr7pe//KX7p3/6J9fU1OS6urpe9We3b9/uAOijjz766HOEf7Zv337A533g3NCbkc6YMQNnnnkmvvSlLwHY/1bT2tqKhQsX4uMf//gBf7a7uxtNTU1oveNahLW5Ad+V92bMn6l7Mf4i1/Riyaxbsytvlme6dtsdKkfxshSJ6FZdAK6vn5T32eXFslFWsK850iBvvUHaXvuwrsau39gQK4sa6826haPsNvJN9h8IUvn4LZPuj68ZAKRIeViw92dA6gf5+PpbZfsvSvYnmVtn/YaaStltkMdF0G/fV65QtNspxstdwR6PK9lz4or2HMLZ96FFQMYZZO39Rstzxh7K2XVdNmuX19j1wd4govg4g5I9drY+6CPlNfE+sn4jHZ/DUjmP9c/dgd27d6OxsdH+ORyGP8EVCgV0dHRgyZIllbIwDDFr1ixs2LAhVj+fzyOf/79J2LNnz/6fqc0hHDVwUV3ZXqBULj6MdMbenOm0fROmw5xZbm5mtiHIxnchKQ/IjRXE++6CIf89YXjCAlBAAlBg3xSBsZ5Ryl7jKG0HoHKGBKDICEDkIZlKkwBUJgEoxcrj8xKE5E/UbH+yAGQFLN8AxG4J1kejL45Ute6H/eXsT/QeASggAYjtK7IPg9Cob5UBcClW7hmAAiMAkWcQWx+E5Lli3D+s33SvAK96jDLkIoQ//vGPKJfLaG5uHlDe3NyMzs7OWP2lS5eisbGx8mltbR3qLgkhhBiGJK6CW7JkCbq7uyuf7du3J90lIYQQrwFD/ie4o48+GqlUCl1dXQPKu7q60NLSEqufy+WQy5E/fwkhhBixDHkAymazmDZtGtatW4cLL7wQwH4Rwrp167BgwYKq2ynvzcTOfFK99gtbyjhHC4vkb9VEKMD+tm2WszaMQ8ED1vfBV5LOxjNcpO20f+SlnJ0lkL8/O+Ng1KXtth37OwA7kzAuGZGzxZCUuyI56zLOegAAxnkU1Q+xNfYpZ/NNDrlZ/YCcX1jnTgE5c6N7xTiL21/fY48zEUKa9CVDzkEy8fMbRwQL1qH9AWHnbmWjnJxFsmeTI8+mwGqHnGfaz0giEBncZFW1PFm8eDHmz5+P6dOn46yzzsJtt92G3t5efOhDHzoclxNCCHEEclgC0MUXX4w//OEPuP7669HZ2Yk3velNePDBB2PCBCGEEK9fDpsTwoIFC7z+5CaEEOL1ReIqOCGEEK9PFICEEEIkwmH7E9yhMup/0zGHg5TtaINRu+JKjsxeW4UR9hNrEKZUKxmuBEyVY9QFAEfKqWrOUBQxKxqKhx2Jt/LMl7JhLUQUTNQahaiSAkN9BAAuF1crlWvsNqIMUWqR4UcZ4//iD4kaj8whXU0257XWT9gODlQdxi5ZiK9PQKyCKOz/hieiMXOdjX1ywLYDYiNjtUPUeNRap7bWbrvWnnNXazhvmGsGrmpjNjqGNRcAwLAiCoj1kWNWPMTiy0XGNQ37JMB2Owii6qzD9AYkhBAiERSAhBBCJIICkBBCiERQABJCCJEIw1aE0Li1jHRm4EFYWLIP77Ld8cO41F77ECxgIgRyMGgKCJjYgOUnIYerTMxgWphnfW1KmMCheut9ZqXunULKOrxkFiDEjoXatBARQmTMV5QlQgFmf0OIrPrsTiICj7BM+kLm3LL6YdZCARN4WNYtAFL74vs2zQ6+2X3CchCxcqMdZpNFV4da8RjtMKENs8shYoOonpSPMkQvtfamCAv2OFO95OCezYshOKBiAyZOYPmawMqNNoyyyEmEIIQQYhijACSEECIRFICEEEIkggKQEEKIRFAAEkIIkQjDVgWX211COj1IncPybxnqOJchKqMaYr1BEjkFhpqMJXGiMJUZswcxbGQCljWWJZoi5aayjVmdsP4xFRxT+1kquHx1KpkKTPFE7EHC3rhvU4ao3cKCfRukSLllr8NsewImGCTjibL2nJdz8fJyzr5outde+0zeXp/Qst0hik6a0JEpJpkKzqMNGPcDwG2bqDLUguxxBrPFCYy5DVmSPk+rJKYkdIYylCoGPRNRmupfZpVkPWuqtALTG5AQQohEUAASQgiRCApAQgghEkEBSAghRCIoAAkhhEiEYauCy7ycR3qwyIWES9P3i6jgAuKpZiWUAoDAUn4UiIKLqcaYAoX5ntWNivevjiTIYqokpkiz+hKb6P8PUwgxnzmmJOz3ULwxnz02TqKmC3r7YmUh897rt1VWqTxJdmctJ1E8RcSvLcrZc142kt0BQKk23k6pxq6byrOEZ6TcUHYxVShbY7qHPBRpLHkfUuQxxXzcfPrB9gTz08sT1aXpsUjG4+ml6NhzxXh+MC9BpoHz0caZalbY92a1fpF6AxJCCJEICkBCCCESQQFICCFEIigACSGESAQFICGEEIkwbFVwgXMxzzEXES+vUvUqjMDyvQJoxkBT9ePjiQRQtRvSRJFnqHusjIv7+8JUPNV7dvlmBKV+WOwHLM8qZ2eWZEqbIE8yPRLPKWfUZ3MSEN8zVyRzbii+2BwGOaLUIvWjMsmgaijYUkyMWbT3RFhg+zZexDOckjkhe5x5Mvp4k9FMtkzpaqiywj6yr1iG5BKZXOaRZzxvQqYYZGo/XyylHlHMWc8UAFyJa60Pe+4ZytXARVUlVdUbkBBCiERQABJCCJEICkBCCCESQQFICCFEIgxbEYJLB9UnszJECCFJvhX0EeuWPvuQ2/XHE5s5chBJLTYCYqXhcWBYriGHhczxwsfugx0IEzuSFBE+AMT+x7JpYcm6SMtmgiyAHgo7y6KHCU2Y8IGts3Vwyw55mTUKsegJU7ZQwlr9sEgS0vWRg3IiwDETDJLxMLGFI2ILKiCwkvqRtku1xLbIsCcCgFQ+PofZl8lcGc8OAMA+Im7ZF7d4AgBYohciMqIJID0tscz7irWR9ltP04qI3SdWmRLSCSGEGM4oAAkhhEgEBSAhhBCJoAAkhBAiERSAhBBCJMLwVcEFQUwpwxRfQWQk1GJ2MUQJZaqmAFtlxSwpGEwRwpRqhmWMZTcE8ARUFEt95KtIY8ouopozlWAs2R1TPoZE3QOiVDNwZN0CR24DDzsj2m8yV2w9wdSbxtyGBdI2aYPZNvklSPNMskbbNtphTaeJOi5HFHmG6jRFVKSpfcTOh60nu5eNKXdl8kwhCkNuZTU0ie3siw6RLdBBojcgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEUAASQgiRCMNWBWfio7RhiixWTrzGLOUUS3ZH22aeYgHxpduzL1aWYm0T7yfq2ZWNLznz66I+Zt6KJw+YKocl8SK+WmZtpvarrTXLXY2dfM3V5GJl0SjiBceuSVRwYZ74tRm+b8wrkSpA2foYCdyY0pNsWZrYLWT709iHLMFcRPZyiqjgzDaIkqxcSxRpffbaBzUkkaLHM4h5QPp6wZn3Cn2+sUSPpH5f3AOTeSlaPo3OVadO1RuQEEKIRFAAEkIIkQgKQEIIIRJBAUgIIUQieAegn/3sZ5gzZw7Gjx+PIAhw3333DfjeOYfrr78e48aNQ21tLWbNmoXnn39+qPorhBBihOCtguvt7cXpp5+OD3/4w7joooti33/uc5/D7bffjnvvvRcTJ07Eddddh9mzZ+PZZ59FDVGQWATOxf2viJdVYJUzHy+WWZP5u/ko7BikbVcgkiKDgPU7Q1Q8VtZOAK42ruBiyjOmpLMy0ALgc27h6UHlkz12f/NG+yRDpRtFlE2jjLmCrZyKckSNR+YqRfzaQpK11PTfY78+smWgKjjLS5Hst5KnDyJTUhrrxrKqpolKs0wypTqjmPkdsnVztUQFl7f3RGApCdk9yzKlsj3OFKAWTL3I1pMp2/rjGV7Z88oZY3euun3iHYAuuOACXHDBBXZHnMNtt92GT3ziE5g7dy4A4Gtf+xqam5tx33334X3ve5/v5YQQQoxQhvQMaOvWrejs7MSsWbMqZY2NjZgxYwY2bNhg/kw+n0dPT8+AjxBCiJHPkAagzs5OAEBzc/OA8ubm5sp3g1m6dCkaGxsrn9bW1qHskhBCiGFK4iq4JUuWoLu7u/LZvn170l0SQgjxGjCkAailpQUA0NXVNaC8q6ur8t1gcrkcGhoaBnyEEEKMfIbUC27ixIloaWnBunXr8KY3vQkA0NPTg02bNuGKK67waivcV0Q42OvKUpqAKDyobxFRpDGFkKHiYQoz7mNGPLtYfSPrIs3YSueEeD8ZKpmQKWSY11i/R/ZYwC+DKFsH5vlGVHAuF1cxuRq7bjTKVjyVa4lqzkPBFxLFJFO7BX1x9RFwgGyZQ4GlXmRqN6bo9PQBtHzpmFIrRTzisiRTajkT31vUG5GURySDalBn+waa88UUaeSeZXs/yNv3slmftGH5tQHg62n6uzEPSGM8LHPsILwD0N69e/HCCy9U/r1161Zs3rwZY8aMwYQJE7Bo0SJ8+tOfxqRJkyoy7PHjx+PCCy/0vZQQQogRjHcAeuKJJ/C2t72t8u/FixcDAObPn4+VK1fi2muvRW9vLz7ykY9g9+7dOOecc/Dggw96/T9AQgghRj7eAeitb33rAV+3gyDAjTfeiBtvvPGQOiaEEGJkk7gKTgghxOuTYZuQLtjXhyAcdJBFE77FD+nooRsr97CRCaiVBjkqDtiBu31Ny9oCZXIQyewxmPDBEjP42Nmw/gF0POZ8RZ7Jt1hiM0NsAABRfdwypUzEBqU6ez1Lo+y+pPLxcYZGGcCteJhIxkwEBpiHy+wvETThGRFymAfX7HDac+2ZSIbenwYxMdL/hz28gjpr7e3aEREyMIsegFjxGEkA6dr3kUSURIBiPd8AMof0+UbECeyvWdY12Z4w2q5WlKI3ICGEEImgACSEECIRFICEEEIkggKQEEKIRFAAEkIIkQjDVgXn0mm41MDuUQsLA2ZdwrQZAVOqGQouZv/ClFrUooepmAyFlCNKmCGBqVt82/Gx0WEWOszmiMxtRJKYRbl4O5Fh0QIAjv0axtyZSvEv0n0kwVw/sUQitjPMKspSWFIrJ6Z2Y3NrVzZLLQsdAP7WPZbq1CcpJGzlGQCk+uJzzp4djijsQtI2u6bduOcd5G2jY4yJKYWZlRVT7lrzUiZ7wljL0IVAr930gHqvXkUIIYQYehSAhBBCJIICkBBCiERQABJCCJEICkBCCCESYdiq4JBJA4NUcC5F1DAeCcICogZhSpMgayQ2G2WnlqAKLs8wHxjKKdPDDaBeW1SBYyiNvFQ2B4IpagxvMsdUcCRpnMsSL68sUcdljWsS3y9GQBRFqYKh+tlH1G7E9wtsPSOmgjPGz/Y9881j6k1r3TyVmzQxIlHHmSpApvSkHpDknjXqp/rsJig0+RopN+59l/ZMushUgOw+ZPUtWHLJDNkTVh/Zc8JKLhgFUsEJIYQYvigACSGESAQFICGEEImgACSEECIRFICEEEIkwvBVwQVBXInDRCWWHxjxCKPKmWL1yiFfpZbzE18htDJaMp85X4zxB/0kqyrJtkpVSQymjvPAdw4tJVRQZj5ZduMBEwEazVh+WPvrkmvSzK/2HjKzyrI9wdpmfbG6zn41ZWvv63tm7QnmYUf2D/WGND3SPBWdDJYl2Cin6tyhmCsAgMczgc0tK7fGwxRz1o9HKeBPr15Pb0BCCCESQQFICCFEIigACSGESAQFICGEEIkwfEUI5Qix01FiJ2Ed/jOLljBP7CSYZYplsZEh9i/MeoOdIZJDyrIxzoCMh9l9OHJwGRbi9h2pXpJoah85oGTJx5hVhwWxEQlKLHGW5yFyFJ8X1oQjIoRSliycUczWgVk/sYR8ARUnxNthydQYzBbHPBQfomRqXgxRQkdThOBhIwPgAIIIMueWyIEIH5jFEyVkfam+Cbqv2Nyazz1mNRZvw5Wr65zegIQQQiSCApAQQohEUAASQgiRCApAQgghEkEBSAghRCIMXxWcc3GFClFsWIq3cl31thEAEDKbFkPdxBRmVO3GYAocS2XFlHcZ+3eIcs4uTxn1A+YWYxcDBZJ8rcDmxbD1IDYqjlglsb44Q+0GAM5KgkfmiiWqC4ykdoBtu8LUUVQ5xGDKNuuaTMHEbGd87IJ8lVoMdq8YKjM6V57J4YLAUPv5JoFjqjEf5aG32o0pKT2UeqzfnlgKS5djKjijbpXJLPUGJIQQIhEUgIQQQiSCApAQQohEUAASQgiRCApAQgghEmH4quBSYUxxYqqPYPtwRcTfK2R+baS+BVONBUU/9VFQIvWZusmilqj9PJoo54jPXJA1y+kcMgWOoTQKWGJAorCj/nNElRRY3mllPz89SzEI2F5eTI0YOnKLsSR4RTKH1vjZvmIKJI/keI54D3r7srF71kjqGJFEjwx2H8K4r4Ii8R5kykCfexAgXnBDo4KjCksr6SbzsKPei+S+ssbPhG3WQlTpDag3ICGEEImgACSEECIRFICEEEIkggKQEEKIRFAAEkIIkQjDVwUXhnH1B8v+aSihmCqJZZG0vMMAIPDJFkn85MI8UXYRJZjdEaLqYyojorKy/NCYRxpTEjJ/L9aXYF/eaJzMYURUOUzx5ZFBlGUhDYlyiKngLDUQ8weMiIcfmyuGpWzzVruxvWJlv6y1FZD+/nOkeFS8/ZKnfyPDUikGJeIbR+eQtE3mNuyL3+NBP7nvGcxnjqnganLxMrbf2DOoSs+2A3IIGXX1BiSEECIRFICEEEIkggKQEEKIRPAKQEuXLsWZZ56J0aNH49hjj8WFF16ILVu2DKjT39+P9vZ2jB07FvX19Zg3bx66urqGtNNCCCGOfLwC0Pr169He3o6NGzfi4YcfRrFYxDve8Q709vZW6lx99dX4wQ9+gDVr1mD9+vXYsWMHLrrooiHvuBBCiCMbLxXcgw8+OODfK1euxLHHHouOjg685S1vQXd3N+655x6sWrUK5513HgBgxYoVmDJlCjZu3Iizzz676muV67MI0gNVHhFRwRVHx4dRrGOqNnvIzJeNqmTMup6ZG5kPkwdU3cIEXGVD8cS83Vi/2TiZt53pk0XqEs8qx/riofhi8x0WiBpxn8e8DNFcBSxDp1VOrumI2o+VlxviaqpCI1PB2cWZHnsfpgx1GCPVb489IplpqYehUUyzGBOYai4kfo9po/0UUwySvgT9Bbs+21uGbyLztqNts+zGxr3C/BstwshQvlr1qm7RoLu7GwAwZswYAEBHRweKxSJmzZpVqTN58mRMmDABGzZsOJRLCSGEGGEc9P8HFEURFi1ahJkzZ+LUU08FAHR2diKbzaKpqWlA3ebmZnR2dprt5PN55PP/Fy17enoOtktCCCGOIA76Dai9vR3PPPMMVq9efUgdWLp0KRobGyuf1tbWQ2pPCCHEkcFBBaAFCxbghz/8IX7605/i+OOPr5S3tLSgUChg9+7dA+p3dXWhpaXFbGvJkiXo7u6ufLZv334wXRJCCHGE4fUnOOccFi5ciLVr1+KRRx7BxIkTB3w/bdo0ZDIZrFu3DvPmzQMAbNmyBdu2bUNbW5vZZi6XQy4XPwQt1WWA9MBDU2avYwkOiqNIgjByjpbKEwuLgpWYiRwK0oR0zHbGoz47iGQWPR6H4mXfpHaeB+imkIOJDTytQRzxTAkCo312KJy3D2jpb2de9kyeSQp97HU8RQiW2AAA8mPi5X1Hk8RmhFFkapkIwxpnWLQPxF3aFkRYYgPAvvdLNcyCy24jnbf7ncozu5zqRQ4ptldYkkafciZsInvc5asTC/jiIiJ6GIRXAGpvb8eqVavwve99D6NHj66c6zQ2NqK2thaNjY247LLLsHjxYowZMwYNDQ1YuHAh2travBRwQgghRj5eAWj58uUAgLe+9a0DylesWIFLL70UAHDrrbciDEPMmzcP+Xwes2fPxp133jkknRVCCDFy8P4T3KtRU1ODZcuWYdmyZQfdKSGEECMfecEJIYRIBAUgIYQQiTBsE9IFZYcgGPgnvyCwFUJhOR5HSVWqnCnVEhWckZQtRdRujjTuimSame2KDywhG8P4Myqzs3GeSdO88LQp4c2wdox5YW0PxTiZ0pGpEVl9mmDQGg9LVGbvt4hY10TZ+DUdm6rq8oy9KmbSuCJRUZL7LSwSpVrBKCcdZyq4kCWwI+tmzRdL9MiSxgVGYsD9bXvsW7bfrASNAALDmgsgalQ3BMnrBqE3ICGEEImgACSEECIRFICEEEIkggKQEEKIRFAAEkIIkQjDVgWX6i8hlR7odRQQ9UiUj6szUoayB+DqnlKtHYtThgrOGWUAn8ygNATTzH5VIMIUn0RtXiqbA/XFpx2i4KJ6NI/x0PZTRAJJFEJUrUTUWj7QBGlsPIZCymXtfVUmKrgySexmwTwTQ+rtZtdn+9BKAMnmNczbnUlZykDY/nMp4u3GVHDEYpCqAK1rsjWO2L7K2R5+AVM7DoF6k6n6glR8fVyJbAqrjaC6vaY3ICGEEImgACSEECIRFICEEEIkggKQEEKIRFAAEkIIkQjDVgWHyMXUFVSxYYhnmJdTRBRsEUkKaqlk0iRul4lCCESVlBoKDzKSnZRl3DSVM6QbTDFIPciIugeleHlQJnUj8juRrwrOULaZfmoAHw9r29hDATUV81xj0pfIyFrL1G7M882lq1eGUq86VsyWjcy5pSRlM8WyqobMO87oe1gg9wnrN1V02sU+MBUtu39YfS9CO6ss9ZI0fCqpmtfwjWNenLHLV1dNCCGEGFoUgIQQQiSCApAQQohEUAASQgiRCApAQgghEmHYquBcJgU3SMnEVDwWzJvKEbVb2cM7LmS+V0ZmVuAAWSSZ0sbMWurXBJhdmaV68fSCi0imx5BtJ0vFxDzCrEyMB4Hpw+WpOqSZYg1POavsoEjbc1uqs1RwRDU1BMou7lVnz0k5x/pt74m0tcc9PfYsPzkApjdZ4KtG9MRS+9Hnled9RRfUY0jMRzMgfoLW3Doy39Z94kim1cHoDUgIIUQiKAAJIYRIBAUgIYQQiaAAJIQQIhGGrwghDGIHoewQ1bTeKBL7jozdBj3+tA5omXaAJqBiVi/kksZZX0gP5/0Ov83DUtJvagFCOh6RA/TQOABlVjyOWYMw2OGyZSXjOU5ebh04s4Niv8NvthaW4IAlUaTJCKmNjpGk0FPIUM7Z9QNirRQW4+MJ+8he9twSlk7CMRsvJhAiVlYsASQyVkNkj1PPIbLffBJAsnWj/SbiBMteh4oQ4mVRlWIivQEJIYRIBAUgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEGLYquKAcIRgkB2P2OmExrrhI7bPrpvpt1Ueml8RiS5FmXA/gSZioisVHwUWgCrYsURR5KGeYmso/QZgxMTSRHFEM+qrMrL4zCxQyV1GOJHzLxvtSNsoArrJiCdJo0kVDgZTqt9umSiim0jSGX65hbZBrEl+YoExUc8Z8pVgiPbbHmbrUVPWxfWIXp/pLZnmYt8utdQsKzA+MyRGrv+/3X6B6uymmUGXPIHM8NEmhJYOrbix6AxJCCJEICkBCCCESQQFICCFEIigACSGESAQFICGEEIkwfFVwpQjBIAkaTcpWiCtTmG9RmngfDYWXF1OaRCRxWJl4jfnYh1G/Mg9PNR/lFQCEzBOKJRSzVHPM94qsD1OqWb5sAElsR33W7NuAJXwr18TbKZGEbCFRDKZ7zWKk8mTOjXbCsj3fTJHniA+is1RwOaamMovpHgpLTHkY72PE1p6o3aw2ACAyEsFFZOx07xNFWsiUbcb6BJHH/QCiFgW4Os64h9h9HzKFIfWCM67J+m0lFyR1Y/2qqpYQQggxxCgACSGESAQFICGEEImgACSEECIRFICEEEIkwrBVwYV9JYSp4oAymumxZKhNiEIoYDIeyxALAAxVCc0UGhBVjqeKx4XxcdIsiswni5V7KOzCsp+/WYqp4IzxoOTnh8WuybQ2lrqHrUOp1l770iiyPmz9DZg/IFV0emQz9fXqC6x1AJAqxMvSvczEzi5mvnTpfo8+0syfdjHN2mosp1dWUQARWWOm1AtCY6Ejorxj+ZdpquXq7xWqpCvaxV6w+TYWyCrzaFIIIYQ4vCgACSGESAQFICGEEIngFYCWL1+OqVOnoqGhAQ0NDWhra8MDDzxQ+b6/vx/t7e0YO3Ys6uvrMW/ePHR1dQ15p4UQQhz5eIkQjj/+eNx8882YNGkSnHO49957MXfuXDz11FM45ZRTcPXVV+P+++/HmjVr0NjYiAULFuCiiy7Co48+6t2xsK8f4eBDU3YYZx28WVYsgFeyNwBwGaMw5Zc4y7IGAbjdiemmQQQO/IC2etsVduDKbGTCIrH76Gd2J2axDbPwYIer5HcoS3DArHWY2KBIyi37ltDOU+aXxAugqgpTcECmhK2bKQYBkO6zGiICDLLfUkUicGDWQkyE4nFNn71PRQjM/YYlRmQClDC+txyzJyJdoVY3rL7Zvm8bpNwYv5ddWZVqJ68ANGfOnAH//sxnPoPly5dj48aNOP7443HPPfdg1apVOO+88wAAK1aswJQpU7Bx40acffbZPpcSQggxwjnoM6ByuYzVq1ejt7cXbW1t6OjoQLFYxKxZsyp1Jk+ejAkTJmDDhg20nXw+j56engEfIYQQIx/vAPT000+jvr4euVwOl19+OdauXYuTTz4ZnZ2dyGazaGpqGlC/ubkZnZ2dtL2lS5eisbGx8mltbfUehBBCiCMP7wD0xje+EZs3b8amTZtwxRVXYP78+Xj22WcPugNLlixBd3d35bN9+/aDbksIIcSRg7cTQjabxUknnQQAmDZtGh5//HF88YtfxMUXX4xCoYDdu3cPeAvq6upCS0sLbS+XyyGXy/n3XAghxBHNIVvxRFGEfD6PadOmIZPJYN26dZg3bx4AYMuWLdi2bRva2toOuaMAuHLIUryViCyJJDBDkSi4LCueLLPi8fC5AVeHWQohphpiYhPWFeejSPMTDHKszrAOUpsjpj6qPuEZT7JWvWIQsNeNWeswfBWTgbXQTEhH2mBqR/N6noosmoCMFRvjLxOrJKperCXqUuP+ZAnpuOqQlBMrr7AY3xRhwb7Z2NoHTHlndwUwpoVaORGYdY8zHp9s7Z11b1aZkM4rAC1ZsgQXXHABJkyYgD179mDVqlV45JFH8NBDD6GxsRGXXXYZFi9ejDFjxqChoQELFy5EW1ubFHBCCCFieAWgXbt24R/+4R+wc+dONDY2YurUqXjooYfw9re/HQBw6623IgxDzJs3D/l8HrNnz8add955WDouhBDiyMYrAN1zzz0H/L6mpgbLli3DsmXLDqlTQgghRj7yghNCCJEICkBCCCESYdgmpHOpFNxgzzWW4MlISOdosi5b9WEmlAJRoFBFFilmvlf99jUt/6wwT5JYeeIsjzSSGI8RGIqfA/+A4c3FFD+e5TTZn6F6stRRAPcJC8iUmwopst9MhRAAx/IimkaA8FIkMr8yqvYzLknnxEPVtr8vpL5VTpK9FevszhTqiAquxlDBZe1+UC80cjMzb79Un1GX3PcBnSumAGXJMo027JoISuS5R5JImuo4ouqzeh2Wq8uApzcgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEUAASQgiRCMNWBYdUGPdtYz5HltKIZaIsM2kTUaDQTJxWXbvY8okCgKBEMpEW4n20yoADeJAxVVYp/jtHUKpeZQMAIVHU0OySprqHKIGIEipiKjiWbdZQ9jE/MJotk2bcNMqY8oxtK3LnmZ5vgJcKjs0Ju6Y1TqbeYyqwkNxW/JrV+9IVR9l1S1QFZ5RZmY3B/RhTBdIXkg3YWh+qfiX3Jn0bYM8yoqaz27CLAzYBPlmmrfGUiRfnIPQGJIQQIhEUgIQQQiSCApAQQohEUAASQgiRCApAQgghEmH4quB8sFQYJPWno35yRLVRjJcHBbsuFaWQbKsMM7skzQZL/KY86qeYqs1TGciu6cK4so15uFledQAQkUy2VuZTwFZfUXUY8ytjd4ehVGNiIp5xc2gydFqUie8ZywhrqgCZLRm9f4iyiyg9rXGyMdLMpzm7vrWeNMMpKWeKyeIou775uzxL+kv2YbqfKF09vBeZSpFlGmYei4H1iGMquENAb0BCCCESQQFICCFEIigACSGESAQFICGEEIkwfEUIQRA/BPew7+CH9vZBnyOHd4EhQgBJ4kSjOesLO9MzDgwdSVRmJo46wDVDIlrwgSbOIn20bHSiHLHcoSIEIiAgSeYswQETG7BkZewg2gvf6aaH5ZYwxa5bJof2JcOiBiDJ4djQmSsMERuYh9mwrXtYXSo2IPY6lr7DVyTChBzMosi2M7L3cobZHDH9gF1sCj+YtoUqpIgIwXp+MOswkyqf1XoDEkIIkQgKQEIIIRJBAUgIIUQiKAAJIYRIBAUgIYQQiTBsVXDluiyC9ED5C7OkSJUMSU2eZJQiFj203Gq7UDSrBlbdgyFt6F6I4oeqTUi5abvik+gP/io4q74jqhxazqxEmLrHRzDJHIeI/MhSVDGVFbVG8VTHmeNkqj6yV6jaL21lU2P9sMt95hsAQuP2DPNs7UlfrH6DqeD8lGdRit0TdnFpX/yLdB9RI/Ywyyq77QzZ41aiS5Ys0kXVq90AIDSsr0L2rDGUta5K2x69AQkhhEgEBSAhhBCJoAAkhBAiERSAhBBCJIICkBBCiEQYxiq4DIL0QDlPWLCVFWE+Lu8J9vWZdR0TqpGEdM5QvAVMDUKSpvniXFzGxK7pMrZEiCWaMpVtTAVHYG07Mn6rPs3HxsQ6ZKfSZHI+KjiqvLPrW8oppnbz9SBjWH2xku4dsDxjX9RSzTmiAouyRMFFyhGSeemPL3Sq7zD+Psz2OLlkOUfGmbMXtLQv3hBTwTFfw7DE/B7NYvNx4+sFx+qnmdLVwNr7rkyM/QZ3q+qrCCGEEEOIApAQQohEUAASQgiRCApAQgghEkEBSAghRCIMWxVcqreI1CBPNOYFZ3mzUS+iaIj82nxgfmDMx2woIKo5K+OoY1lIidrNyjYKDJEvG/N88/W8M9rx9UhjmThtPz3iNUa2G/WIY750Rt9pplByV1OFoaWm8vRfQ5YoVLP2BERh/AJllvqTKQapktKSKZI2MsRfstZWceVytg/kvt21sbISebyme1l2X7MYZZL1N7D2HFtkz0dN2chYzO5vay+Xq/TF1BuQEEKIRFAAEkIIkQgKQEIIIRJBAUgIIUQiDF8Rwu59SKUGHmQFTFjQ1x8rckWSkI4RkFhsJgJjddkBoKfvinGwzg7h6eE8wRIcFOvsbVCqrT7BHMBtccJSfPxhdU4d/4endY91EB+Rw1x6mE/Krb6wJQ7tM2uAJEhj47H6WK4hTTOhAE0mZ1ipsLps62fsQ+c0KbeWn+VMY5NLHbEMYUGWiAdqc/ZzoqEmb5aPztrlz0fHxMryffYNwcQw5QwTDtnjL1t7yPdRQx6pZeO5F5H+WdcsFasLLXoDEkIIkQgKQEIIIRJBAUgIIUQiKAAJIYRIhEMKQDfffDOCIMCiRYsqZf39/Whvb8fYsWNRX1+PefPmoaur61D7KYQQYoRx0Cq4xx9/HF/+8pcxderUAeVXX3017r//fqxZswaNjY1YsGABLrroIjz66KN+F9jTG5MQOWZfYijeXJHIrIhSLWA2INY1mRqPwfpNCCwbC6a8Y9Y15HeLyGiHqd2Ko/x+PwlY0q9yvI+B85tDb7Wfh0uJl6UL/Gx+WMIvpj5iifdKo6wyZufjafNjXNMRixpqXZO2y7NZ+z5Mp+N7PMrZC5RKkWuGdnltNq54G52z1Wt1aVsFN4qUp0Nb1ZfNxMfZz5L6EZUiVWmSclPxxu4T36SThgrO5/4pF9kDdSAH9Qa0d+9eXHLJJfjKV76Co446qlLe3d2Ne+65B7fccgvOO+88TJs2DStWrMD//M//YOPGjQdzKSGEECOUgwpA7e3teOc734lZs2YNKO/o6ECxWBxQPnnyZEyYMAEbNmww28rn8+jp6RnwEUIIMfLx/hPc6tWr8eSTT+Lxxx+PfdfZ2YlsNoumpqYB5c3Nzejs7DTbW7p0KT71qU/5dkMIIcQRjtcb0Pbt23HVVVfhm9/8JmpqyP+G7cmSJUvQ3d1d+Wzfvn1I2hVCCDG88QpAHR0d2LVrF9785jcjnU4jnU5j/fr1uP3225FOp9Hc3IxCoYDdu3cP+Lmuri60tLSYbeZyOTQ0NAz4CCGEGPl4/Qnu/PPPx9NPPz2g7EMf+hAmT56Mj33sY2htbUUmk8G6deswb948AMCWLVuwbds2tLW1eXXM9fXBDc7mFTHpkOFlVbbVKkHKVmfQnFdBXN1C6zKlmi/GeAI2duYRlyHjNLrIVDZM2ZXK2zOQKtjl6X7DC65gj4clvWLJumgiOKN5YykPWB4Wq1fesSRwqE4MVMGROS82xAcUNZCOG6rD/T/AJHnGuhEFF0swxzzfagx1GABk0/HyDFG11RP/tYZM3AMSAGpTcRUcU68x+sr2Quwt2gaBZWpkF4cl+2N7vFTDfCCrb5tJIJlK0+oLe06Yz5R8dfPhFYBGjx6NU089dUBZXV0dxo4dWym/7LLLsHjxYowZMwYNDQ1YuHAh2tracPbZZ/tcSgghxAhnyN2wb731VoRhiHnz5iGfz2P27Nm48847h/oyQgghjnAOOQA98sgjA/5dU1ODZcuWYdmyZYfatBBCiBGMvOCEEEIkggKQEEKIRBi2GVFdX39cBecDy3DKTLiYhxJR01k4apbkh9kT6rNWvTIQsH3MmHKGlbMptNRugK14S/fb81o2Mrbub8QuD8tEkWckwGQ+ay5P1p5lWzXmhSkGWRtMfVTOEZ+wuvh85Ubb6rBSiWTiLLAFNVSXxAcvRdRuOaJ2q8vanmpNub5Y2dhcr1m3OWe7o4zLdpvlGUPW2E/khd2WyR6AHflGs3x3wa5vwrzgWEZUkoGXPgYtvzbiM8f2G/MHLBvKuxL5Xz+t50TZ3pox9AYkhBAiERSAhBBCJIICkBBCiERQABJCCJEICkBCCCESYfiq4CIHN0idExCfMEvxRn3ZMrYEJcgSaYqljiN+cr4ETHlntZ8m1yTlzAvOIjQUYwBNtopU0VbaBCVSTpRqZl0mUiRtp/vsHwjK8fVP2YIspIhip2xbjZneXEzBxBRPrJwlM7X83ZjazRHPt4BkFg0MtRbLQlqTszdLY609WUfX7jXLx9fGFWytNX8y656Q/aNZ/hcZuzxluDW+VK4z6/4hbZsfZ4j0LEUWqCcfl4gViOqwSNanSGSn1B/R2ENhgT0j7WKmjrMUo1QtazxqqxUE6w1ICCFEIigACSGESAQFICGEEImgACSEECIRhq0IwQvrkI4IBZjYIMiSbFDEAuawYgkLWCK9tN2/iJRbooqQiQfIgThLSMdscZiwwK7rl+zOkaRxqX4jgVvarpvus+eqnLPrF+ri9Yt1dt1yrVlMD4Vp3sFS/Aeiot1vZqPD3KnS6fiBezZrW+uMrrEVG2NqbBudlpo9Zvmk2l2xsjfmdth1My+b5RMz9WZ52cUncVfZbmN7eZ9ZnoLHpgWwuy6+0P0l+/H6EkleV3L2M8gFxFrJaD6VqT6J4v62PSr7NV0VegMSQgiRCApAQgghEkEBSAghRCIoAAkhhEgEBSAhhBCJMGxVcEEYxK1qiIzHUrAFOVtREtTasiQ3imRbshR2RKnlDbHYsGx0HFHBlRvscRbr7aUt1cTnMCLKGWanYVnRAEBEbIECKzke8fVgybeoUq9kq5UsRR5T73HIfrO2EEteR+4wZsXD7E5g2Le4PrvxwRZWr0bZ2G+lnN122bA4OhAh6UtDOp6QrjFlK+kaQtvmpym0FWy5IN73DLG9Ghvaqr5i5iWznLEvit+HJXIDRUR69idSbrgwAQCcYTdG8u7BcCc6cLllr+OhgouIErOKywghhBCHHwUgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEGLYqOARhTPXGksxZ/m5Bja1qc/W2Cq48+tBVcJ7iI54MylAlRVl77EztVhjNPOIO3dApYpnqGEZ1NvY0UaqlDW83AEj1keRrxXh9q4z1D+CJwCy/OlaXqdqijD3OiNQ31YF5cj+wYRKFoaXIK5O2+4j/nPMyFQNGpePZAetJZsC60M4kODrsMsvHGPVriIJ2DFm3ELbCriawPfLKxu/yKbIQTAVXIgrDbjfKbsdQ+zG1LN0TpNzaty5NHnDWI5IkNByM3oCEEEIkggKQEEKIRFAAEkIIkQgKQEIIIRJBAUgIIUQiDFsVXJBNIwgGynMCpvDIGDIe4ktmZQQFeCZO0yvJ8jY7AFwhRRRFVnUmQCFZSMOix3g8YR5xVE1mzbmvkM7XI85QvIUF0gjZE+zmSBsKsXQfydhKFYNkH5IumqoktsV9VXDGQKMCycJJjMlstzbgZSIN3ZlpjJXVpopmXaYmYxyXjmc/bSSeb3Wh3XaRrE+G9KUmiPd9FFPvZey+1Ofs+vlaeyfmjS6WiVLNsey5Rqbd/V8YbXjIfKutqzcgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEGL4ihFwOQTgoyVNITl3TxjBClk3NPokNe+2DQS/IYbZlrXOgchgHg44coNOEbOwQOWMksSIH5Y7sDiqqIOeZ1iE3O0BPFezDy1SeWPH0k/XMxy1TgiKpa3eF+uJk9hhzSMYeFuzWU7YjFMos2V82Xs6S3VHIubB1W7G1ZwnpSuQH+mBbXO0yrFpyKdvmhlEkm+ilTH2s7Nh0j1mXJbXLEMudFJnEfiMTHOtfSNrIpe1rjsrZ4ozQSPpWsJ6FAErsedDPFjq+34IiUxnFi6i4YRB6AxJCCJEICkBCCCESQQFICCFEIigACSGESAQFICGEEIkwfFVwtTUIwlx1lZntjtVuwVaU+NrrmDDlXdmwCvK8JjV0IUnWmO1MlLWS3RGFDEmC51IkmZpHsjuWwIxZCKXyRMHG1IGG4o2p4BghWZ90r6EQIkvJVH2lfqImI3kRy0Z5iSjmeII9Um6p4JggLSIKSPK7bNlImgYAe9PxAe1MjTbrFsv2/uwt2c+HP+biKrhdmQaz7lHpXrO8jlj3WJY7ANBVjFsLvVy0E8n1secBIZ2y9621VUKyEYlTFBxRNTprzqkdmHE/kH0yGL0BCSGESAQFICGEEImgACSEECIRFICEEEIkglcA+uQnP4kgCAZ8Jk+eXPm+v78f7e3tGDt2LOrr6zFv3jx0dXUNeaeFEEIc+Xir4E455RT8+Mc//r8G/sx76Oqrr8b999+PNWvWoLGxEQsWLMBFF12ERx991LtjrrYGLjVI5UJUSUHRkOwwtVvJlve4skfSK+KFFhAfpoCp3cpElWUl3iPJ68CSj0X2F6ZIhnnYUdUUUc6QefFJPscSAwY08ZyHRx5Z44CoF5lfHU1sZ/bDbiSVJwo7K8sYgKLhKUfynSHK2uXlHPGZswqZtx1Rx6X7yT1BfscthnEl2G7U2XWJCq5AvPp6inF9WGfaVsGxJHhZMtAcKd9djJv77S3aKr09Rv8AYG/BXrgC2UOWkpTqaonqdCjEv+ZeqfKe9w5A6XQaLS0tsfLu7m7cc889WLVqFc477zwAwIoVKzBlyhRs3LgRZ599tu+lhBBCjGC8z4Cef/55jB8/HieeeCIuueQSbNu2DQDQ0dGBYrGIWbNmVepOnjwZEyZMwIYNG2h7+XwePT09Az5CCCFGPl4BaMaMGVi5ciUefPBBLF++HFu3bsW5556LPXv2oLOzE9lsFk1NTQN+prm5GZ2dnbTNpUuXorGxsfJpbW09qIEIIYQ4svD6E9wFF1xQ+e+pU6dixowZOOGEE/Dtb38btbUkwcmrsGTJEixevLjy756eHgUhIYR4HXBIMuympia84Q1vwAsvvICWlhYUCgXs3r17QJ2uri7zzOgVcrkcGhoaBnyEEEKMfA7JC27v3r34zW9+gw9+8IOYNm0aMpkM1q1bh3nz5gEAtmzZgm3btqGtrc27bTcqF1fBkeyfgZHl1BWJCo6o41yBSIoMhVTAVGBE1RawcqKaQyZe7owyAAgCIoMjw7cIaUZUD9UUuGrMrkxUbURgRtVuzN/NynzLJD+sL6y+4b+XIgo75mFnZaYFgFQ/yaJpZLRMFe02CnVMpWiPx1kqSKaCs4u5TxjNjBkfT4n4h+01vMYAIIrs3vRk4uozJtBMhfa6pT3Li0ZfyqR/RZZVlqj9fIRqbE4imq7YQ6J6GPAKQNdccw3mzJmDE044ATt27MANN9yAVCqF97///WhsbMRll12GxYsXY8yYMWhoaMDChQvR1tYmBZwQQogYXgHod7/7Hd7//vfjpZdewjHHHINzzjkHGzduxDHHHAMAuPXWWxGGIebNm4d8Po/Zs2fjzjvvPCwdF0IIcWTjFYBWr159wO9ramqwbNkyLFu27JA6JYQQYuQjLzghhBCJoAAkhBAiEYZtRlQ4F1MnMX8zWOXE8w3Ow/MNQGAphJh6zfJwA+Co4ot5wRm/F7CxsyysxN/NUnyZvmng/mvcf46Ul+PtsMyn6T573aj/GpsXaw7JXEWjbA+uUp2dudKar5DNoTF21gbAfyNMMRmXQURUjSxjreX5V/Z8MjCPOJBlc32WjxnLqmqvwz4yJfl0vL6v5RnLLBoQJWFg1Ge3oFX3YIgMBZtVBgBRiXlJEg8/Q70YFkhdS6VIPA1jbVZVSwghhBhiFICEEEIkggKQEEKIRFAAEkIIkQhHlAiBWqlYNijkgN8r8RxgCguohQ5L7EYOyp1lFwM7QZophgDg2AoSQYQlIOAiBHJQTg7WSbGZfI2JDVL77PKgQE65SQI7pOPjj7L2ZJXq7UPuQoNdP91nzAvpdxgxeyYmWqh+fwbE+yjKkINoYv9j7aEys24h001FCEwjYrn/MFuYgFjXBGQ9repMIEPGWWZCAXa2nolfIDDKACBM222HxObHziJp2+44YlvkqAiBXNISIRSZYMEoJM5msTarqyaEEEIMLQpAQgghEkEBSAghRCIoAAkhhEgEBSAhhBCJMGxVcEG+hGCwkotZ1zB1nNUuU5MxSxurLlMwkUR1FGavYiYI80wc5WP/Q1R6IblmKkssbYgFTKo/fk1vtRvDULsBQFQT39pRja12K9bbt0G+gVgrGeNktkUBUelRNxayFlY7gZEYD+A2RymiTIqMYTrSQZakkGYpZFhbiCWNy9vlLiRKT8Mux7SLAbhHD6tOrHiiWstaiLVhP8dCoppjWFvFkWR3YOMn5ZayLSRJLq25dTQR4aA2q6olhBBCDDEKQEIIIRJBAUgIIUQiKAAJIYRIBAUgIYQQiTB8VXCFAoLBKjHqBWeoSpgXGks05ZOojvh7OdYG8bKiqjmj3Pkq7HyS9xFCNt9pv76Ehu9b0GdLagIPRSMAuAxRweXiW7tUZ2/3Qr09nkIDUQgZ/mGpfruNkKiSHFPHefxOyBR2IVHkpQps7ePXJEItROSJYSW1AwBiV2crCUndVD9TVFUvYaM+c6QJlyIqQKL0tMZJFYOkOJ0mCkjyzCqX4hd1bJxM7VYk+9ZQsVn+cPvrxstclWJWvQEJIYRIBAUgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEGLYqOITh/s+fwxRSuWysKOYj9wq+mVItZZunUot6vlGlnqfvmwdMOWVBM7YSvzY2zLA/rngLCsRYikFUgI55+xn1WaZQpuBimNek3mEsO6m99gHLimksG1vLVJ7scSbKMn2/WL/tNsrxW/D/lxPllOlXx1SHdttM2cbG6QNbN5aB2LyViayPaRH7PH3por54Z4I8UbXlyToUiH+jUZ96wZl7064ba7O6akIIIcTQogAkhBAiERSAhBBCJIICkBBCiERQABJCCJEIw1YFF9XXIkrlBhbSLJ9GOfM8K5JMnETxZdV3ngqugGVb9cjCyhRP1COOtG16c7G5IgqzoMQyqBLVXN7wgmNzyFRtxFTMzPDKYNZ2eTK3PXZ5Zl98/CwjKlXpEXUYU3aFho9bQLzdQqKCy5A+Rpn4Xinn7P1TrmHZcJkZnF1sZWdlHnYR2SpU1Wg81Xy96qiIi3icpXstf0CiJDTqAkCU9nscp415YepFS+kIcLWaVU6z+Hq0Oxi9AQkhhEgEBSAhhBCJoAAkhBAiERSAhBBCJMLwFSHUpBGlB/l+sCReVjE5WA/y5NQxb5yKgiRIK5ETPQ+bmwNiXZMJBdjhb5qM04IlsWLjoXNLyi3BAZlvZk9EU5J55BFk2LYwQIY0njJEC6YQBuAWPSyxGbMzsgqZGISMh4l4wmz8MRAWyToQLxomCIhIUjbzvmLbjbVN5txKmkcFC2z/MEckcltZSdmIJocLbTwthMxrsvGwRxNNyFdd2f6LGnWr1GnpDUgIIUQiKAAJIYRIBAUgIYQQiaAAJIQQIhEUgIQQQiTCsFXBeWEoapgqKWBWPMwaxlJreVrxeOaZspVgLEkdsUyJDGUTAPNXjqBILHSIyoraGZFyaw5dgajgiB1JwGyBWHJAY5xUecaSj3nYt7C2A6JIY0njgiJRtvXF5zbsJ3PoqcY017lkr0PaMxkjU+RZ8xURlRVbH5DkeNYNFxZIP0jbzCWL7QlrnCFZHmppw4SUNCFf9W34Yo2TqeAs9R6b71g9jz4JIYQQQ4YCkBBCiERQABJCCJEI3gHo97//PT7wgQ9g7NixqK2txWmnnYYnnnii8r1zDtdffz3GjRuH2tpazJo1C88///yQdloIIcSRj1cAevnllzFz5kxkMhk88MADePbZZ/GFL3wBRx11VKXO5z73Odx+++246667sGnTJtTV1WH27Nno7+8f8s4LIYQ4cvFSwX32s59Fa2srVqxYUSmbOHFi5b+dc7jtttvwiU98AnPnzgUAfO1rX0NzczPuu+8+vO9976v+YpGLqXmoesQnIR1LYEa8yVwxrnhzzAuOQH3MWH1LaUQ80sAUXEaSMcBOYEd/CyFTGJbJF/15+5rWHBIlIVUGsmRdRJVlJYJjvmRU3eOhjmN1A2I2xpLGhX1kXvrj5QHz0/NUqll7KyQJGlkCQJqksGBL1ayEdzTZXcYeT4kqI63+mVWpipIqIJn1ovH7teUZCPDEeyFT7vrkXPT9mxbzKjT2M50To40SUXMOxqu73//+9zF9+nS85z3vwbHHHoszzjgDX/nKVyrfb926FZ2dnZg1a1alrLGxETNmzMCGDRt8LiWEEGKE4xWAXnzxRSxfvhyTJk3CQw89hCuuuAIf/ehHce+99wIAOjs7AQDNzc0Dfq65ubny3WDy+Tx6enoGfIQQQox8vP4EF0URpk+fjptuugkAcMYZZ+CZZ57BXXfdhfnz5x9UB5YuXYpPfepTB/WzQgghjly83oDGjRuHk08+eUDZlClTsG3bNgBAS0sLAKCrq2tAna6ursp3g1myZAm6u7srn+3bt/t0SQghxBGKVwCaOXMmtmzZMqDsueeewwknnABgvyChpaUF69atq3zf09ODTZs2oa2tzWwzl8uhoaFhwEcIIcTIx+tPcFdffTX+6q/+CjfddBPe+9734rHHHsPdd9+Nu+++G8B+v65Fixbh05/+NCZNmoSJEyfiuuuuw/jx43HhhRd6dSzV049UapAqhKl7DMVbwJRafbYc3BGZuLPaYRlBmVKN+ZtliZmVZURFMp864vkW5fxUYxbU240o2BxTElqqQUMZBxzAyoopnvYRz7Lu+NwyxVOUZuoruzwwvNaY92BYIOqwfuKnZ6jdAOJVyNZnCKAee4SQmKdZqkuAKBI95aJWRlBGiniTsQyiEfMNJLe41X6aZAhm/nhM7WbtN8AzgyrzkiS40JISelyuShWcVwA688wzsXbtWixZsgQ33ngjJk6ciNtuuw2XXHJJpc61116L3t5efOQjH8Hu3btxzjnn4MEHH0RNTY3PpYQQQoxwvN2w3/Wud+Fd73oX/T4IAtx444248cYbD6ljQgghRjbyghNCCJEICkBCCCESYfgmpHu5Bwiz1dU17E5M8QC4jQ5LkGYmQmPZqpgdS5qcXBIRgnlwSw4RqQghSw7QTdsiu3vMtsiy1gEAl7eteCzRBlufAL7iBHucKWO+wnzObpvOob1uzhAt0MRmBWJdUyAiBGavYwgOmJ0R3YfsINoS1RBBDT2HZuNnifpq43Nu2ScBB0jIRg7tLUsbaotD2igTfZCPCIElZaPCFCJk8Uoy56c1oLC1qPrnWTLLQegNSAghRCIoAAkhhEgEBSAhhBCJoAAkhBAiERSAhBBCJMLwVcGVCnFFB7OksGxDfBPSMcWXobIKmAqOKLKoao4pTTyUd8yOwzH1EZlDn7qOlbO5teqTRG2ODChg68mSAxoKMaoCI7DfzsztRmx7qPURs4qi5cbckjlERPYK24ZmZabI8hsPsyjysvphKjgyfKuc1/VTx0VMqWfZM3n070B9MRNuAn72Op6vGoGX9M64HNvHg+sd0lWEEEKIg0QBSAghRCIoAAkhhEgEBSAhhBCJMOxECK8ICkrOsCQhB5emCIEd0DoiNiDlVowOSNsBPUAncZ4d5lu/F5AT5HLJvmapRA5XLYuMMsnjE9nWOi6y60eOWMN4rQ+bW1ZuN2POORVP+IkqnCEIiYgAJSRthGV7bgMy54gMKx6jbH8j7PdKD4se1kZE5oRZX5HbytKOlIp25TI5bI/IeCyRjCM5eJj9TUTuZVYOI/8NvSaxqaEH9wmIEA6VUmn/PjafzX9G4F6txmvM7373O7S2tibdDSGEEIfI9u3bcfzxx9Pvh10AiqIIO3bswOjRo7Fnzx60trZi+/btIzpVd09Pj8Y5Qng9jBHQOEcaQz1O5xz27NmD8ePH02y5wDD8E1wYhpWI+cqfBhoaGkb04r+CxjlyeD2MEdA4RxpDOc7GxsZXrSMRghBCiERQABJCCJEIwzoA5XI53HDDDcjl7ERiIwWNc+TwehgjoHGONJIa57ATIQghhHh9MKzfgIQQQoxcFICEEEIkggKQEEKIRFAAEkIIkQjDOgAtW7YMf/EXf4GamhrMmDEDjz32WNJdOiR+9rOfYc6cORg/fjyCIMB999034HvnHK6//nqMGzcOtbW1mDVrFp5//vlkOnuQLF26FGeeeSZGjx6NY489FhdeeCG2bNkyoE5/fz/a29sxduxY1NfXY968eejq6kqoxwfH8uXLMXXq1Mr/uNfW1oYHHnig8v1IGONgbr75ZgRBgEWLFlXKRsI4P/nJTyIIggGfyZMnV74fCWN8hd///vf4wAc+gLFjx6K2thannXYannjiicr3r/UzaNgGoG9961tYvHgxbrjhBjz55JM4/fTTMXv2bOzatSvprh00vb29OP3007Fs2TLz+8997nO4/fbbcdddd2HTpk2oq6vD7Nmz0d/f/xr39OBZv3492tvbsXHjRjz88MMoFot4xzvegd7e3kqdq6++Gj/4wQ+wZs0arF+/Hjt27MBFF12UYK/9Of7443HzzTejo6MDTzzxBM477zzMnTsXv/zlLwGMjDH+OY8//ji+/OUvY+rUqQPKR8o4TznlFOzcubPy+e///u/KdyNljC+//DJmzpyJTCaDBx54AM8++yy+8IUv4KijjqrUec2fQW6YctZZZ7n29vbKv8vlshs/frxbunRpgr0aOgC4tWvXVv4dRZFraWlxn//85ytlu3fvdrlczv37v/97Aj0cGnbt2uUAuPXr1zvn9o8pk8m4NWvWVOr86le/cgDchg0bkurmkHDUUUe5f/u3fxtxY9yzZ4+bNGmSe/jhh91f//Vfu6uuuso5N3LW8oYbbnCnn366+d1IGaNzzn3sYx9z55xzDv0+iWfQsHwDKhQK6OjowKxZsyplYRhi1qxZ2LBhQ4I9O3xs3boVnZ2dA8bc2NiIGTNmHNFj7u7uBgCMGTMGANDR0YFisThgnJMnT8aECROO2HGWy2WsXr0avb29aGtrG3FjbG9vxzvf+c4B4wFG1lo+//zzGD9+PE488URccskl2LZtG4CRNcbvf//7mD59Ot7znvfg2GOPxRlnnIGvfOUrle+TeAYNywD0xz/+EeVyGc3NzQPKm5ub0dnZmVCvDi+vjGskjTmKIixatAgzZ87EqaeeCmD/OLPZLJqamgbUPRLH+fTTT6O+vh65XA6XX3451q5di5NPPnlEjXH16tV48sknsXTp0th3I2WcM2bMwMqVK/Hggw9i+fLl2Lp1K84991zs2bNnxIwRAF588UUsX74ckyZNwkMPPYQrrrgCH/3oR3HvvfcCSOYZNOzcsMXIob29Hc8888yAv6ePJN74xjdi8+bN6O7uxn/8x39g/vz5WL9+fdLdGjK2b9+Oq666Cg8//DBqamqS7s5h44ILLqj899SpUzFjxgyccMIJ+Pa3v43a2toEeza0RFGE6dOn46abbgIAnHHGGXjmmWdw1113Yf78+Yn0aVi+AR199NFIpVIxpUlXVxdaWloS6tXh5ZVxjZQxL1iwAD/84Q/x05/+dEBCqpaWFhQKBezevXtA/SNxnNlsFieddBKmTZuGpUuX4vTTT8cXv/jFETPGjo4O7Nq1C29+85uRTqeRTqexfv163H777Uin02hubh4R4xxMU1MT3vCGN+CFF14YMWsJAOPGjcPJJ588oGzKlCmVPzcm8QwalgEom81i2rRpWLduXaUsiiKsW7cObW1tCfbs8DFx4kS0tLQMGHNPTw82bdp0RI3ZOYcFCxZg7dq1+MlPfoKJEycO+H7atGnIZDIDxrllyxZs27btiBqnRRRFyOfzI2aM559/Pp5++mls3ry58pk+fTouueSSyn+PhHEOZu/evfjNb36DcePGjZi1BICZM2fG/peI5557DieccAKAhJ5Bh0XaMASsXr3a5XI5t3LlSvfss8+6j3zkI66pqcl1dnYm3bWDZs+ePe6pp55yTz31lAPgbrnlFvfUU0+5//3f/3XOOXfzzTe7pqYm973vfc/94he/cHPnznUTJ050fX19Cfe8eq644grX2NjoHnnkEbdz587KZ9++fZU6l19+uZswYYL7yU9+4p544gnX1tbm2traEuy1Px//+Mfd+vXr3datW90vfvEL9/GPf9wFQeB+9KMfOedGxhgt/lwF59zIGOc///M/u0ceecRt3brVPfroo27WrFnu6KOPdrt27XLOjYwxOufcY4895tLptPvMZz7jnn/+effNb37TjRo1yn3jG9+o1Hmtn0HDNgA559wdd9zhJkyY4LLZrDvrrLPcxo0bk+7SIfHTn/7UAYh95s+f75zbL4O87rrrXHNzs8vlcu788893W7ZsSbbTnljjA+BWrFhRqdPX1+euvPJKd9RRR7lRo0a5d7/73W7nzp3Jdfog+PCHP+xOOOEEl81m3THHHOPOP//8SvBxbmSM0WJwABoJ47z44ovduHHjXDabdccdd5y7+OKL3QsvvFD5fiSM8RV+8IMfuFNPPdXlcjk3efJkd/fddw/4/rV+BikdgxBCiEQYlmdAQgghRj4KQEIIIRJBAUgIIUQiKAAJIYRIBAUgIYQQiaAAJIQQIhEUgIQQQiSCApAQrwErV66MOSoL8XpHAUiIV6GzsxNXXXUVTjrpJNTU1KC5uRkzZ87E8uXLsW/fvqS7J8QRi9IxCHEAXnzxRcycORNNTU246aabcNpppyGXy+Hpp5/G3XffjeOOOw5/93d/l3Q3hTgi0RuQEAfgyiuvRDqdxhNPPIH3vve9mDJlCk488UTMnTsX999/P+bMmQMAuOWWW3Daaaehrq4Ora2tuPLKK7F3717a7m9+8xvMnTsXzc3NqK+vx5lnnokf//jHle9//etfY9SoUVi1alWl7JX8NM8++yx+9rOfIZPJxBKFLVq0COeee+4Qz4IQhwcFICEIL730En70ox+hvb0ddXV1Zp0gCADsTxl/++2345e//CXuvfde/OQnP8G1115L2967dy/+9m//FuvWrcNTTz2Fv/mbv8GcOXMquVkmT56Mf/3Xf8WVV16Jbdu24Xe/+x0uv/xyfPazn8XJJ5+Mt7zlLTjxxBPx9a9/vdJmsVjEN7/5TXz4wx8ewlkQ4jBy2GxOhTjC2bhxowPgvvvd7w4oHzt2rKurq3N1dXXu2muvNX92zZo1buzYsZV/r1ixwjU2Nh7weqeccoq74447BpS9853vdOeee647//zz3Tve8Q4XRVHlu89+9rNuypQplX9/5zvfcfX19W7v3r3VDlGIRNEbkBCePPbYY9i8eTNOOeUU5PN5AMCPf/xjnH/++TjuuOMwevRofPCDH8RLL71ERQp79+7FNddcgylTpqCpqQn19fX41a9+VXkDeoWvfvWr+MUvfoEnn3wSK1eurLxxAcCll16KF154ARs3bgSwX2n33ve+l76tCTHcUAASgnDSSSchCIJYFskTTzwRJ510EmprawEAv/3tb/Gud70LU6dOxXe+8x10dHRg2bJlAIBCoWC2fc0112Dt2rW46aab8F//9V/YvHkzTjvttFj9n//85+jt7UVvby927tw54Ltjjz0Wc+bMwYoVK9DV1YUHHnhAf34TRxRSwQlBGDt2LN7+9rfjS1/6EhYuXEjfLDo6OhBFEb7whS8gDPf/Tvftb3/7gG0/+uijuPTSS/Hud78bwP43ot/+9rcD6vzpT3/CpZdein/5l3/Bzp07cckll+DJJ5+sBD4A+Md//Ee8//3vx/HHH4+//Mu/xMyZMw9hxEK8tugNSIgDcOedd6JUKmH69On41re+hV/96lfYsmULvvGNb+DXv/41UqkUTjrpJBSLRdxxxx148cUX8fWvfx133XXXAdudNGkSvvvd72Lz5s34+c9/jr//+79HFEUD6lx++eVobW3FJz7xCdxyyy0ol8u45pprBtSZPXs2Ghoa8OlPfxof+tCHhnz8QhxWkj6EEmK4s2PHDrdgwQI3ceJEl8lkXH19vTvrrLPc5z//edfb2+ucc+6WW25x48aNc7W1tW727Nnua1/7mgPgXn75ZedcXISwdetW97a3vc3V1ta61tZW96UvfWlAuut7773X1dXVueeee67yM5s2bXKZTMb953/+54D+XXfddS6VSrkdO3Yc1nkQYqhRSm4hjnAuu+wy/OEPf8D3v//9pLsihBc6AxLiCKW7uxtPP/00Vq1apeAjjkgUgIQ4Qpk7dy4ee+wxXH755Xj729+edHeE8EZ/ghNCCJEIUsEJIYRIBAUgIYQQiaAAJIQQIhEUgIQQQiSCApAQQohEUAASQgiRCApAQgghEkEBSAghRCIoAAkhhEiE/wfhaumUhdSQfQAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
       ],
-      "text/plain": [
-       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
+      "source": [
+        "# Look at some processed samples!\n",
+        "\n",
+        "n_samples = 9\n",
+        "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+        "for image, label in samples:\n",
+        "    image = transforms(image)\n",
+        "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+        "    plt.xlabel(label_map[label.item()])\n",
+        "    plt.show()\n"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def make_model(): \n",
-    "    \n",
-    "    # Define the input size\n",
-    "    in_layer = Input((28, 28))\n",
-    "\n",
-    "    # Perform some convolutions \n",
-    "    x = Conv1D(filters=4, kernel_size=2)(in_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(in_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Flatten()(x)\n",
-    "    # Decode the convolutional output into an array\n",
-    "    x = Dense(20, activation='relu')(x)\n",
-    "\n",
-    "    x = Dropout(0.3)(x)\n",
-    "\n",
-    "    # Get the output class probabilities \n",
-    "    output = Dense(1, activation='sigmoid')(x)\n",
-    "    model = Model(in_layer, output)\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "model = make_model()\n",
-    "loss = tf.losses.BinaryCrossentropy()\n",
-    "optimizer = tf.keras.optimizers.SGD(0.01)\n",
-    "\n",
-    "# Compile tells the keras backend what loss and optimizer to use to perform gradients on the model\n",
-    "# You cannot train a keras model without compiling it first\n",
-    "model.compile(loss=loss, optimizer=optimizer)\n",
-    "\n",
-    "# Show what layers are in the model, and their input and output shapes \n",
-    "# This can help make sure all your stuff is a correct size\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train the model \n",
-    "\n",
-    "We have all the pieces in place:\n",
-    "- [x] Model \n",
-    "- [x] Train Data \n",
-    "- [x] Validation Data \n",
-    "- [x] Loss Function \n",
-    "- [x] Optimizer \n",
-    "\n",
-    "Now lets put this together into a fit model. \n",
-    "Keras trains in place, so you don't need a new variable to hold the `fit_model` vs `model`. \n",
-    "Once you call `fit`, the model is fit, and it re-train, you need to make a new model with the `make_model()` function. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/50\n",
-      "\u001b[1m 1/20\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m6s\u001b[0m 344ms/step - loss: 0.7196"
-     ]
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HJEKKWHpARAx"
+      },
+      "source": [
+        "## Make the binary classification model\n",
+        "\n",
+        "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+        "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+        "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+        "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+        "\n",
+        "In this case, what we want:\n",
+        "* Take the input images from the data generator\n",
+        "* Apply two convolutional blocks to the input image\n",
+        "* Decode the second convolution block's output to a probability of the image being a given class."
+      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/maggiev-local/miniforge3/envs/ss_tutorials/lib/python3.12/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
-      "  self._warn_if_super_not_called()\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yb6L7SDoARAx",
+        "outputId": "4a606080-485d-4ca0-b451-6f125eea10c2"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "----------------------------------------------------------------\n",
+            "        Layer (type)               Output Shape         Param #\n",
+            "================================================================\n",
+            "            Conv2d-1           [-1, 16, 64, 64]             160\n",
+            "              ReLU-2           [-1, 16, 64, 64]               0\n",
+            "         MaxPool2d-3           [-1, 16, 32, 32]               0\n",
+            "            Conv2d-4           [-1, 32, 32, 32]           4,640\n",
+            "              ReLU-5           [-1, 32, 32, 32]               0\n",
+            "         MaxPool2d-6           [-1, 32, 16, 16]               0\n",
+            "            Conv2d-7           [-1, 64, 16, 16]          18,496\n",
+            "              ReLU-8           [-1, 64, 16, 16]               0\n",
+            "         MaxPool2d-9             [-1, 64, 8, 8]               0\n",
+            "           Linear-10                  [-1, 128]         524,416\n",
+            "             ReLU-11                  [-1, 128]               0\n",
+            "          Dropout-12                  [-1, 128]               0\n",
+            "           Linear-13                    [-1, 1]             129\n",
+            "================================================================\n",
+            "Total params: 547,841\n",
+            "Trainable params: 547,841\n",
+            "Non-trainable params: 0\n",
+            "----------------------------------------------------------------\n",
+            "Input size (MB): 0.02\n",
+            "Forward/backward pass size (MB): 1.97\n",
+            "Params size (MB): 2.09\n",
+            "Estimated Total Size (MB): 4.08\n",
+            "----------------------------------------------------------------\n",
+            "None\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Create a simple convolusional model\n",
+        "\n",
+        "class SimpleCNN(torch.nn.Module):\n",
+        "    def __init__(self):\n",
+        "      super().__init__()\n",
+        "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+        "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+        "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+        "\n",
+        "      # Pooling layer\n",
+        "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+        "\n",
+        "      # Fully connected layers\n",
+        "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+        "      # 64 channels * 8x8 = 4096 input features\n",
+        "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+        "      self.fc2 = torch.nn.Linear(128, 1)\n",
+        "\n",
+        "      # Dropout\n",
+        "      self.dropout = torch.nn.Dropout(0.3)\n",
+        "\n",
+        "      # Activation\n",
+        "      self.relu = torch.nn.ReLU()\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+        "      if x.dim() == 3:\n",
+        "          x = x.unsqueeze(1)  # Now (batch_size, 1, 64, 64)\n",
+        "\n",
+        "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+        "      x = self.pool(self.relu(self.conv1(x)))\n",
+        "\n",
+        "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+        "      x = self.pool(self.relu(self.conv2(x)))\n",
+        "\n",
+        "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+        "      x = self.pool(self.relu(self.conv3(x)))\n",
+        "\n",
+        "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+        "      x = x.view(x.size(0), -1)\n",
+        "\n",
+        "      # Fully connected layers\n",
+        "      x = self.relu(self.fc1(x))\n",
+        "      x = self.dropout(x)\n",
+        "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+        "\n",
+        "      return torch.softmax(x.squeeze(), 0) # Output of (batch_size)\n",
+        "\n",
+        "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1m13/20\u001b[0m \u001b[32m━━━━━━━━━━━━━\u001b[0m\u001b[37m━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 23ms/step - loss: 0.7027"
-     ]
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "NqOS_59-ARAy"
+      },
+      "source": [
+        "## Training process\n",
+        "\n",
+        "Based on the previous lessons, we know we need a few things to train a model\n",
+        "\n",
+        "### Loss and Optimizer\n",
+        "\n",
+        "\n",
+        "### Training and Validation data loops\n",
+        "\n"
+      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/maggiev-local/miniforge3/envs/ss_tutorials/lib/python3.12/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
-      "  self._warn_if_super_not_called()\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "id": "CPJDwFxSARAy"
+      },
+      "outputs": [],
+      "source": [
+        "# Random choices of optimizer and loss functions\n",
+        "# These are pretty standard for classification\n",
+        "optimizer = torch.optim.Adam(SimpleCNN().parameters(), lr=0.001)\n",
+        "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)\n",
+        "\n"
+      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 42ms/step - loss: 0.7016 - val_loss: 0.6924\n",
-      "Epoch 2/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 39ms/step - loss: 0.6935 - val_loss: 0.6898\n",
-      "Epoch 3/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.6845 - val_loss: 0.6854\n",
-      "Epoch 4/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 39ms/step - loss: 0.6825 - val_loss: 0.6820\n",
-      "Epoch 5/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 38ms/step - loss: 0.6904 - val_loss: 0.6772\n",
-      "Epoch 6/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.6820 - val_loss: 0.6696\n",
-      "Epoch 7/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.6686 - val_loss: 0.6584\n",
-      "Epoch 8/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.6683 - val_loss: 0.6519\n",
-      "Epoch 9/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.6617 - val_loss: 0.6364\n",
-      "Epoch 10/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 39ms/step - loss: 0.6537 - val_loss: 0.6176\n",
-      "Epoch 11/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.6292 - val_loss: 0.5954\n",
-      "Epoch 12/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.5707 - val_loss: 0.5651\n",
-      "Epoch 13/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.5833 - val_loss: 0.5337\n",
-      "Epoch 14/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.5388 - val_loss: 0.5104\n",
-      "Epoch 15/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.5583 - val_loss: 0.4788\n",
-      "Epoch 16/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.4495 - val_loss: 0.4471\n",
-      "Epoch 17/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.4636 - val_loss: 0.4222\n",
-      "Epoch 18/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.4695 - val_loss: 0.3941\n",
-      "Epoch 19/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.4557 - val_loss: 0.3754\n",
-      "Epoch 20/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.3648 - val_loss: 0.3461\n",
-      "Epoch 21/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.3671 - val_loss: 0.3200\n",
-      "Epoch 22/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.3570 - val_loss: 0.3101\n",
-      "Epoch 23/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.3379 - val_loss: 0.3009\n",
-      "Epoch 24/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.3183 - val_loss: 0.3250\n",
-      "Epoch 25/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 34ms/step - loss: 0.3330 - val_loss: 0.3016\n",
-      "Epoch 26/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2995 - val_loss: 0.2629\n",
-      "Epoch 27/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.3274 - val_loss: 0.2719\n",
-      "Epoch 28/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 34ms/step - loss: 0.2903 - val_loss: 0.2680\n",
-      "Epoch 29/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 34ms/step - loss: 0.2717 - val_loss: 0.2781\n",
-      "Epoch 30/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2965 - val_loss: 0.2485\n",
-      "Epoch 31/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.2596 - val_loss: 0.2503\n",
-      "Epoch 32/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2431 - val_loss: 0.2375\n",
-      "Epoch 33/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2730 - val_loss: 0.2270\n",
-      "Epoch 34/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2812 - val_loss: 0.2255\n",
-      "Epoch 35/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.2572 - val_loss: 0.2446\n",
-      "Epoch 36/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2892 - val_loss: 0.2085\n",
-      "Epoch 37/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2782 - val_loss: 0.2195\n",
-      "Epoch 38/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 40ms/step - loss: 0.3044 - val_loss: 0.2136\n",
-      "Epoch 39/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2722 - val_loss: 0.2084\n",
-      "Epoch 40/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 39ms/step - loss: 0.2731 - val_loss: 0.2218\n",
-      "Epoch 41/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2242 - val_loss: 0.2198\n",
-      "Epoch 42/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2543 - val_loss: 0.2182\n",
-      "Epoch 43/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.2482 - val_loss: 0.2029\n",
-      "Epoch 44/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 34ms/step - loss: 0.3031 - val_loss: 0.2136\n",
-      "Epoch 45/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2334 - val_loss: 0.2099\n",
-      "Epoch 46/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2446 - val_loss: 0.2319\n",
-      "Epoch 47/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.2239 - val_loss: 0.2520\n",
-      "Epoch 48/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.2825 - val_loss: 0.1996\n",
-      "Epoch 49/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.2069 - val_loss: 0.2404\n",
-      "Epoch 50/50\n",
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.2737 - val_loss: 0.2116\n"
-     ]
-    }
-   ],
-   "source": [
-    "history = model.fit(\n",
-    "    train_generator_scaled, \n",
-    "    validation_data=val_generator_scaled, \n",
-    "    epochs=50, \n",
-    "    verbose=1\n",
-    "    ).history\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Evaluation \n",
-    "\n",
-    "There are some steps we can take to see how well a model trained. \n",
-    "\n",
-    "### Loss Plots \n",
-    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training. \n",
-    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem. \n",
-    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6XyF3QGjARAy"
+      },
+      "source": [
+        "# Train the model\n",
+        "\n",
+        "We have all the pieces in place:\n",
+        "- [x] Model\n",
+        "- [x] Train Data\n",
+        "- [x] Validation Data\n",
+        "- [x] Loss Function\n",
+        "- [x] Optimizer"
+      ]
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": 43,
+      "metadata": {
+        "id": "adEJ4vhuARAy"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "def train_epoch(model, dataloader, optimizer, criterion):\n",
+        "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+        "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+        "    n_batches = len(dataloader)\n",
+        "    for images, labels in dataloader:\n",
+        "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+        "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+        "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+        "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+        "      optimizer.step() # Update the model parameters using the computed gradients\n",
+        "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+        "\n",
+        "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+        "\n",
+        "\n",
+        "def val_epoch(model, dataloader, criterion):\n",
+        "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+        "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+        "    n_batches = len(dataloader)\n",
+        "    with torch.no_grad(): # Disable gradient computation for validation\n",
+        "        for images, labels in dataloader:\n",
+        "            outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+        "            loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+        "            batch_loss += loss.item() # Accumulate the loss for this batch\n",
+        "\n",
+        "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+        "\n",
+        "\n",
+        "n_epochs = 10\n",
+        "model = SimpleCNN()\n",
+        "loss_history = {\"train\": [], \"val\": []}\n",
+        "for epoch in range(n_epochs):\n",
+        "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+        "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+        "    loss_history[\"train\"].append(train_loss)\n",
+        "    loss_history[\"val\"].append(val_loss)\n",
+        "\n"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "Eval.plot_loss_history(history) \n",
-    "# Eval.plot_history is a simple function \n",
-    "# plots the loss as a function of epoch "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classification Accuracy Plots \n",
-    "\n",
-    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training. \n",
-    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it. \n",
-    "\n",
-    "### ROC\n",
-    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate. \n",
-    "It shows how likely a model is to correctly predict something. \n",
-    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves. \n",
-    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/Roc_curve.svg/800px-Roc_curve.svg.png\" width=\"300\">\n",
-    "\n",
-    "<a href=\"https://upload.wikimedia.org/wikipedia/commons/3/36/Roc-draft-xkcd-style.svg\"></a><a href=\"//commons.wikimedia.org/wiki/File:Roc-draft-xkcd-style.svg#filelinks\" title=\"File:Roc-draft-xkcd-style.svg\">Roc-draft-xkcd-style.svg</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\" title=\"Creative Commons Attribution-Share Alike 4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=109730045\">Link</a>\n",
-    "\n",
-    "\n",
-    "### Confusion Matrix\n",
-    "\n",
-    "Confusion matrices are a great tool for seeing how well each class does against each other. \n",
-    "It gets it name from its ability to tell if a model is \"confusing\" two different classes. \n",
-    "It plots the rate of predicted values for a given class versus the true values. \n",
-    "\n",
-    "<img src=\"https://www.ibm.com/content/dam/connectedassets-adobe-cms/worldwide-content/creative-assets/s-migr/ul/g/c8/a7/binary-matrix.component.complex-narrative-xl.ts=1712087356966.png/content/adobe-cms/us/en/topics/confusion-matrix/jcr:content/root/table_of_contents/body/content_section_styled/content-section-body/complex_narrative_390941229/items/content_group/image\" width='400'>\n",
-    "\n",
-    " <a href=\"https://www.ibm.com/topics/confusion-matrix\">Link</a>\n",
-    "\n",
-    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1m 4/20\u001b[0m \u001b[32m━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step"
-     ]
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3QCcxf0dARAy"
+      },
+      "source": [
+        "## Model Evaluation\n",
+        "\n",
+        "There are some steps we can take to see how well a model trained.\n",
+        "\n",
+        "### Loss Plots\n",
+        "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+        "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+        "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/maggiev-local/miniforge3/envs/ss_tutorials/lib/python3.12/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
-      "  self._warn_if_super_not_called()\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 44,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "id": "pfDIpqHGARAy",
+        "outputId": "1ed28344-a60a-4792-c3bd-77ce7551f2a2"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+        "# Eval.plot_history is a simple function\n",
+        "# plots the loss as a function of epoch"
+      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 22ms/step\n",
-      "The binary classification accuracy on the test set is: 0.891406238079071\n"
-     ]
-    }
-   ],
-   "source": [
-    "test_generator = SkyGenerator(n_samples=1280, train=False, shuffle=True, pre_processing=processor)\n",
-    "\n",
-    "def make_prediction(test_generator): \n",
-    "    predictions = model.predict(test_generator)\n",
-    "    prediction_classes = np.where(predictions<0.5, 0, 1)\n",
-    "    labels = test_generator.labels\n",
-    "    return prediction_classes, labels\n",
-    "\n",
-    "def test_quality(prediction, labels): \n",
-    "    accuracy = tf.keras.metrics.BinaryAccuracy()(prediction, labels)\n",
-    "    return accuracy.numpy()\n",
-    "\n",
-    "prediction, labels = make_prediction(test_generator)\n",
-    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "V_9R4WYqARAy"
+      },
+      "source": [
+        "## Classification Accuracy Plots\n",
+        "\n",
+        "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+        "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+        "\n",
+        "### ROC\n",
+        "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+        "It shows how likely a model is to correctly predict something.\n",
+        "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+        "\n",
+        "\n",
+        "### Confusion Matrix\n",
+        "\n",
+        "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+        "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+        "It plots the rate of predicted values for a given class versus the true values.\n",
+        "\n",
+        " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+      ]
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": 46,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 313
+        },
+        "id": "iP_xgNcMARAy",
+        "outputId": "e34e8613-39fb-4235-afc0-4465b1315fab"
+      },
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "AttributeError",
+          "evalue": "'numpy.ndarray' object has no attribute 'float'",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+            "\u001b[0;32m/tmp/ipykernel_40524/3837159380.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mprediction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmake_prediction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_generator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/tmp/ipykernel_40524/3837159380.py\u001b[0m in \u001b[0;36mtest_quality\u001b[0;34m(prediction, labels)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_quality\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprediction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m     \u001b[0maccuracy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprediction\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Compute the accuracy by comparing the predicted classes to the true labels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0maccuracy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'float'"
+          ]
+        }
+      ],
+      "source": [
+        "test_generator = SkyGenerator(n_samples=1280, dataset=SkyDataset, shuffle=True, transform=transforms)\n",
+        "\n",
+        "def make_prediction(model, test_generator):\n",
+        "    prediction_classes = []\n",
+        "    for images, _ in test_generator.get_dataloader():\n",
+        "        predictions = model(transforms(images))\n",
+        "        prediction_classes += torch.where(predictions<0.5, 0, 1)\n",
+        "    labels = test_generator.dataset.labels\n",
+        "\n",
+        "\n",
+        "    return prediction_classes, labels\n",
+        "\n",
+        "def test_quality(prediction, labels):\n",
+        "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+        "    return accuracy.numpy()\n",
+        "\n",
+        "prediction, labels = make_prediction(model, test_generator)\n",
+        "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5f5Q78_IARAy",
+        "outputId": "17227148-f746-4a06-a93e-2c8acf4ba7fb"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# And now run them on your own data!\n",
+        "Eval.ROC_curve(prediction, labels)\n",
+        "Eval.confusion_matrix(prediction, labels)"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
-   ],
-   "source": [
-    "# And now run them on your own data! \n",
-    "Eval.ROC_curve(prediction, labels)\n",
-    "Eval.confusion_matrix(prediction, labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "base",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.13"
+    },
+    "orig_nbformat": 4,
+    "colab": {
+      "provenance": []
+    }
   },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file

From 37811d92bf48ac18fdd1dc2562939142d052c6a5 Mon Sep 17 00:00:00 2001
From: voetberg <magpie127@gmail.com>
Date: Fri, 8 May 2026 15:04:20 -0500
Subject: [PATCH 2/3] Introduce new a set of problems, documentation, produce a
 default 'anwser key' notebook

---
 Challenge/challenge_utilities.py     |  134 ++-
 Challenge/guide/anwser_guide.md      |   60 +-
 Challenge/guide/challenge_main.ipynb | 1574 +++++++++++---------------
 3 files changed, 774 insertions(+), 994 deletions(-)

diff --git a/Challenge/challenge_utilities.py b/Challenge/challenge_utilities.py
index 906a286..a78d73f 100644
--- a/Challenge/challenge_utilities.py
+++ b/Challenge/challenge_utilities.py
@@ -5,13 +5,16 @@
 import torch
 from torch.utils.data import Dataset, DataLoader
 from sklearn.metrics import roc_curve, confusion_matrix
+from typing import TYPE_CHECKING
+import torchvision 
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
 
 class SkyDataset(Dataset):
     """PyTorch Dataset for generating sky images."""
-    def __init__(self, n_samples, image_size=28, pre_processing=None, shuffle=False, seed=42):
+    def __init__(self, n_samples:int, image_size: int=28, shuffle:bool=False, seed:int=42):
         self.n_samples = n_samples
-        self.pre_processing = pre_processing
         self.shuffle = shuffle
         self.image_size = image_size
         self.seed = seed
@@ -41,7 +44,7 @@ def decide_labels(self):
         
         return np.asarray(labels)
     
-    def generate_image(self, label):
+    def generate_image(self, label:int):
         """Override in subclasses to change image generation."""
         radius = self.rng.integers(low=1, high=self.image_size // 2)
         center_x = self.rng.integers(low=1, high=self.image_size)
@@ -64,15 +67,12 @@ def generate_image(self, label):
                 center_x=center_x, center_y=center_y
             )
         
-        if self.pre_processing is not None:
-            image = self.pre_processing(image)
-        
         return image
     
-    def get(self, idx):
+    def get(self, idx:int) -> tuple[torch.Tensor, torch.Tensor]:
         return self.__getitem__(idx)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.labels)
     
     def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
@@ -92,8 +92,8 @@ def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
 
 class SkyGenerator:
     """Factory class that returns PyTorch DataLoader for SkyDataset."""
-    def __init__(self, n_samples, dataset, shuffle=False, batch_size=64, seed=42, transform=None):
-        self.dataset = dataset(n_samples, seed=seed)
+    def __init__(self, n_samples: int, dataset, shuffle: bool=False, batch_size: int=64, seed: int=42, transform: "Callable | None"=None):
+        self.dataset = dataset(n_samples, seed=seed, transform=transform, shuffle=shuffle)
         self.shuffle = shuffle
         self.batch_size = batch_size
     
@@ -108,15 +108,53 @@ def get_dataloader(self):
     def __len__(self):
         return len(self.dataset)
 
+class TestDataset(SkyDataset):
+    def __init__(self, n_samples, seed=42, shuffle=False):
+        super().__init__(n_samples, image_size=64, seed=seed, shuffle=shuffle)
+
 
 class SkyDataset01(SkyDataset):
     def __init__(self, n_samples, seed=42, shuffle=False):
-        super().__init__(n_samples, image_size=64, pre_processing=None, seed=seed, shuffle=shuffle)
+        
+        self.size_options = [i for i in range(10, 30)]
+        self.random_augment = torchvision.transforms.v2.RandomApply([
+            torchvision.transforms.v2.CenterCrop(size=16),
+            torchvision.transforms.v2.ColorJitter(brightness=0.5),
+            torchvision.transforms.v2.ColorJitter(contrast=0.5),
+            torchvision.transforms.v2.ColorJitter(saturation=0.5),
+        ])
+        super().__init__(n_samples, image_size=64, seed=seed, shuffle=shuffle)
+
+    def generate_image(self, label):
+        image_size = int(self.image_size + self.rng.choice(self.size_options))
 
+        radius = self.rng.integers(low=1, high=image_size // 2)
+        center_x = self.rng.integers(low=1, high=image_size)
+        center_y = self.rng.integers(low=1, high=image_size)
+        
+        if label == 0:
+            image = StarObject(
+                image_dimensions=(image_size, image_size),
+                noise_level=self.noise_level,
+                radius=radius
+            ).create_object(
+                center_x=center_x, center_y=center_y
+            )
+        else:
+            image = GalaxyObject(
+                image_dimensions=(image_size, image_size),
+                noise_level=self.noise_level,
+                radius=radius
+            ).create_object(
+                center_x=center_x, center_y=center_y
+            )
+        img = torch.from_numpy(image).float().unsqueeze(dim=0)
+        transformed_image = torchvision.transforms.v2.Resize(self.image_size)(self.random_augment(img))
+        return transformed_image
 
 class SkyDataset02(SkyDataset):
     def __init__(self, n_samples, seed=42, shuffle=False):
-        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+        super().__init__(n_samples, image_size=64, seed=seed, shuffle=shuffle)
     
     def decide_labels(self):
         n_stars = (self.rng.integers(low=int(.85*self.n_samples), high=int(.95*self.n_samples)))
@@ -131,10 +169,10 @@ def decide_labels(self):
 
 class SkyDataset03(SkyDataset):
     def __init__(self, n_samples, seed=42, shuffle=False):
-        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+        super().__init__(n_samples, image_size=28, seed=seed, shuffle=shuffle)
 
     def decide_labels(self):
-        n_stars = int((self.rng.integers(low=int(.15*self.n_samples), high=int(.25*self.n_samples))))
+        n_stars = int((self.rng.integers(low=int(.2*self.n_samples), high=int(.3*self.n_samples))))
         n_galaxies = int(.5 * (self.n_samples - n_stars))
         wild_card = self.n_samples - (n_stars + n_galaxies)
         labels = [0 for _ in range(n_stars)] + [1 for _ in range(n_galaxies)] + [2 for _ in range(wild_card)]
@@ -146,20 +184,24 @@ def decide_labels(self):
     
     def generate_image(self, label):
         if label == 2:
-            return np.zeros((self.image_size, self.image_size))
+            return torch.randn((self.image_size, self.image_size)) * self.noise_level  # Generate random noise for wildcard class
         else:
             return super().generate_image(label)
     
     def __getitem__(self, idx):
         image, label = super().__getitem__(idx)
         # Convert label 2 (wildcard) to label 0 (Star)
-        label = torch.where(label == 2, torch.tensor(0), label)
+        if self.rng.random() < 0.5:
+          convert = torch.tensor(0)
+        else:
+          convert = torch.tensor(1)
+        label = torch.where(label == 2, convert, label)
         return image, label
 
 
 class SkyDataset04(SkyDataset):
     def __init__(self, n_samples, seed=42, shuffle=False):
-        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+        super().__init__(n_samples, image_size=28, seed=seed, shuffle=shuffle)
 
     def decide_labels(self):
         n_stars = (self.rng.integers(low=int(.45*self.n_samples), high=int(.65*self.n_samples)))
@@ -171,13 +213,65 @@ def decide_labels(self):
             self.rng.shuffle(labels)
         
         return np.asarray(labels)
+    
+    def __getitem__(self, idx):
+        image, label = super().__getitem__(idx)
+        return image.numpy(), label.numpy()
 
 
 class SkyDataset05(SkyDataset):
-    def __init__(self, n_samples, seed=42, shuffle=False):
-        self.noise_level = 0.25  # Increase noise level for this dataset
-        super().__init__(n_samples, image_size=28, pre_processing=None, seed=seed, shuffle=shuffle)
+    def __init__(self, n_samples:int, image_size: int=28, shuffle:bool=False, seed:int=42):
+        self.noise_level = 0.25
+        self.regression_labels = torch.zeros(n_samples, 3, dtype=torch.float32)
+        super().__init__(n_samples, image_size=image_size, shuffle=shuffle, seed=seed)
 
+    def _generate_all_images(self):
+        """Generate all images once and store them."""
+        images = []
+        for index, label in enumerate(self.labels):
+            image, reg_label = self.generate_image(label)
+            images.append(image)
+            self.regression_labels[index] = reg_label
+        return np.stack(images)
+    
+    def generate_image(self, label:int):
+        """Override in subclasses to change image generation."""
+        radius = self.rng.integers(low=1, high=self.image_size // 2)
+        center_x = self.rng.integers(low=1, high=self.image_size)
+        center_y = self.rng.integers(low=1, high=self.image_size)
+        regression_label = torch.tensor([center_x, center_y, radius], dtype=torch.float32)
+
+        if label == 0:
+            image = StarObject(
+                image_dimensions=(self.image_size, self.image_size),
+                noise_level=self.noise_level,
+                radius=radius
+            ).create_object(
+                center_x=center_x, center_y=center_y
+            )
+        else:
+            image = GalaxyObject(
+                image_dimensions=(self.image_size, self.image_size),
+                noise_level=self.noise_level,
+                radius=radius
+            ).create_object(
+                center_x=center_x, center_y=center_y
+            )
+
+        return image, regression_label
+    
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
+        image = self.images[idx]
+        label = self.regression_labels[idx].to(torch.float32)
+        
+        # Convert to torch tensors
+        image = torch.from_numpy(image).float()
+        
+        # Add channel dimension if needed (for grayscale images)
+        if image.dim() == 2:
+            image = image.unsqueeze(0)
+        
+        return image, label
 
 class Eval: 
     @staticmethod
diff --git a/Challenge/guide/anwser_guide.md b/Challenge/guide/anwser_guide.md
index 724b35e..7f47831 100644
--- a/Challenge/guide/anwser_guide.md
+++ b/Challenge/guide/anwser_guide.md
@@ -1,42 +1,36 @@
-## Common Mistakes 
+# Common Mistakes 
 
-### Imports
-* line 8 - incorrect import name
+## imports
+* Missing the "torch" import
+* Misspelled "SkyDataset" as "SkaiDataset"
 
-### `make_model` 
-* line 9 - in_layer != input_layer 
-* line 19 - model = Model(in_layer, x) -> `model = Model(in_layer, output)`
+## data processing
+* Transformer uses "randomresized" instead of a resize to 64x64
+* Missing labels on the EDA, too many images being plotted
+* Missing a `squeeze` on imshow
 
-### `train_model`
-* line 12 - too few validation samples 
-* line 16 - validation data is set to the train data 
-* line 17 - `epoch` spelled incorrectly
+## model
+* Using a "softmax" over the output function, for a binary problem this should be sigmoid
+* Missing an "unsqueeze" to resize 
+* Missing the 3rd conv block
 
-### `eval_model`
-* line 8 - No parameter for the generator named "test"
-* line 10 - wrong name for the model
-* line 11 - wrong np.where order of 1/0
+## training
+* Missing the optimizer step in training 
+* Validation step still includes the gradient
+* Only trains for 2 epochs
 
+# Notebook 1
+* Random input size, need to make sure the resize is doing it's job
 
-# Notebook 1 - 
+# Notebook 2
+* Imbalanced training data - 85-95% stars. 
 
-Very low learning rate - The model will never learn. 
-Incorrect loss function - swap to a binary classification loss. 
+# Notebook 3
+* The data includes a ton of completely empty images with very large noise levels
 
-# Notebook 2 - 
+# Notebook 4
+* Extra class in the training data. Write a function that removes label N=3, or weight it 0. 
+* Images are returned as numpy arrays and not torch tensors
 
-Imbalanced training data - 85-95% stars. 
-Correct by weighting the labels in the training loop. 
-
-# Notebook 3 - 
-
-The data includes a ton of completely empty images. 
-A pre-processing function can be written to filter these out.
-
-# Notebook 4 - 
-
-Extra class in the training data. Write a function that removes label N=3, or weight it 0. 
-
-# Notebook 5 - 
-
-A pre-processing function is applied to the training data but not the validation or testing data. 
\ No newline at end of file
+# Notebook 5 
+* This isn't a classification problem! It's a regression problem! - labels are 1x3 of radius, center x and center y. 
\ No newline at end of file
diff --git a/Challenge/guide/challenge_main.ipynb b/Challenge/guide/challenge_main.ipynb
index 8dcd9f7..bee76f2 100644
--- a/Challenge/guide/challenge_main.ipynb
+++ b/Challenge/guide/challenge_main.ipynb
@@ -1,953 +1,645 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "jToNcYCsARAt"
-      },
-      "source": [
-        "## Model Training Challenge!\n",
-        "\n",
-        "In this notebook, there are a whole host of weird errors.\n",
-        "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
-        "Do your best to sniff out the mistakes in both code and training procedure!\n",
-        "\n",
-        "Your mission, should you choose to accept it, is:\n",
-        "* Work together in groups of 4 to complete this notebook\n",
-        "* Figure out all the coding mistakes and make a notebook that runs\n",
-        "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-        "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "RX8h5B-GARAt"
-      },
-      "source": [
-        "This line below installs a non-standard data generation package.\n",
-        "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
-        "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
-        "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "id": "VPUeGpTrARAu",
-        "outputId": "3c57ef4c-fddf-4249-d1d3-9d54be9dd48d"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Collecting deepbench\n",
-            "  Downloading deepbench-0.2.3-py3-none-any.whl.metadata (6.4 kB)\n",
-            "Collecting astropy<6.0.0,>=5.2.2 (from deepbench)\n",
-            "  Downloading astropy-5.3.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.4 kB)\n",
-            "Requirement already satisfied: autograd<2.0,>=1.5 in /usr/local/lib/python3.12/dist-packages (from deepbench) (1.8.0)\n",
-            "Requirement already satisfied: h5py>=3.9.0 in /usr/local/lib/python3.12/dist-packages (from deepbench) (3.16.0)\n",
-            "Requirement already satisfied: matplotlib<4.0.0,>=3.7.1 in /usr/local/lib/python3.12/dist-packages (from deepbench) (3.10.0)\n",
-            "Collecting numpy<2.0.0,>=1.25.0 (from deepbench)\n",
-            "  Downloading numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n",
-            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.0/61.0 kB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hRequirement already satisfied: pyyaml<7.0,>=6.0 in /usr/local/lib/python3.12/dist-packages (from deepbench) (6.0.3)\n",
-            "Collecting scikit-image<0.24.0,>=0.23.0 (from deepbench)\n",
-            "  Downloading scikit_image-0.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (14 kB)\n",
-            "Requirement already satisfied: pyerfa>=2.0 in /usr/local/lib/python3.12/dist-packages (from astropy<6.0.0,>=5.2.2->deepbench) (2.0.1.5)\n",
-            "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.12/dist-packages (from astropy<6.0.0,>=5.2.2->deepbench) (26.1)\n",
-            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (1.3.3)\n",
-            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (0.12.1)\n",
-            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (4.62.1)\n",
-            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (1.5.0)\n",
-            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (11.3.0)\n",
-            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (3.3.2)\n",
-            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4.0.0,>=3.7.1->deepbench) (2.9.0.post0)\n",
-            "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (1.16.3)\n",
-            "Requirement already satisfied: networkx>=2.8 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (3.6.1)\n",
-            "Requirement already satisfied: imageio>=2.33 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (2.37.3)\n",
-            "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (2026.4.11)\n",
-            "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.12/dist-packages (from scikit-image<0.24.0,>=0.23.0->deepbench) (0.5)\n",
-            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.7.1->deepbench) (1.17.0)\n",
-            "INFO: pip is looking at multiple versions of tifffile to determine which version is compatible with other requirements. This could take a while.\n",
-            "Collecting tifffile>=2022.8.12 (from scikit-image<0.24.0,>=0.23.0->deepbench)\n",
-            "  Downloading tifffile-2026.5.2-py3-none-any.whl.metadata (32 kB)\n",
-            "  Downloading tifffile-2026.3.3-py3-none-any.whl.metadata (31 kB)\n",
-            "Downloading deepbench-0.2.3-py3-none-any.whl (33 kB)\n",
-            "Downloading astropy-5.3.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.3 MB)\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.3/10.3 MB\u001b[0m \u001b[31m76.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hDownloading numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.0 MB)\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.0/18.0 MB\u001b[0m \u001b[31m71.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hDownloading scikit_image-0.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (14.9 MB)\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.9/14.9 MB\u001b[0m \u001b[31m77.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hDownloading tifffile-2026.3.3-py3-none-any.whl (243 kB)\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m244.0/244.0 kB\u001b[0m \u001b[31m18.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hInstalling collected packages: numpy, tifffile, scikit-image, astropy, deepbench\n",
-            "  Attempting uninstall: numpy\n",
-            "    Found existing installation: numpy 2.0.2\n",
-            "    Uninstalling numpy-2.0.2:\n",
-            "      Successfully uninstalled numpy-2.0.2\n",
-            "  Attempting uninstall: tifffile\n",
-            "    Found existing installation: tifffile 2026.4.11\n",
-            "    Uninstalling tifffile-2026.4.11:\n",
-            "      Successfully uninstalled tifffile-2026.4.11\n",
-            "  Attempting uninstall: scikit-image\n",
-            "    Found existing installation: scikit-image 0.25.2\n",
-            "    Uninstalling scikit-image-0.25.2:\n",
-            "      Successfully uninstalled scikit-image-0.25.2\n",
-            "  Attempting uninstall: astropy\n",
-            "    Found existing installation: astropy 7.2.0\n",
-            "    Uninstalling astropy-7.2.0:\n",
-            "      Successfully uninstalled astropy-7.2.0\n",
-            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
-            "jax 0.7.2 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
-            "xarray-einstats 0.10.0 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
-            "pytensor 2.38.2 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
-            "jaxlib 0.7.2 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
-            "shap 0.51.0 requires numpy>=2, but you have numpy 1.26.4 which is incompatible.\n",
-            "opencv-python 4.13.0.92 requires numpy>=2; python_version >= \"3.9\", but you have numpy 1.26.4 which is incompatible.\n",
-            "tobler 0.14.0 requires numpy>=2.0, but you have numpy 1.26.4 which is incompatible.\n",
-            "opencv-python-headless 4.13.0.92 requires numpy>=2; python_version >= \"3.9\", but you have numpy 1.26.4 which is incompatible.\n",
-            "opencv-contrib-python 4.13.0.92 requires numpy>=2; python_version >= \"3.9\", but you have numpy 1.26.4 which is incompatible.\n",
-            "rasterio 1.5.0 requires numpy>=2, but you have numpy 1.26.4 which is incompatible.\u001b[0m\u001b[31m\n",
-            "\u001b[0mSuccessfully installed astropy-5.3.4 deepbench-0.2.3 numpy-1.26.4 scikit-image-0.23.2 tifffile-2026.3.3\n"
-          ]
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "application/vnd.colab-display-data+json": {
-              "pip_warning": {
-                "packages": [
-                  "numpy"
-                ]
-              },
-              "id": "eb01b87d27a04ef696a480954b2b96e9"
-            }
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "! pip install deepbench"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "xatOAXZ6ARAu"
-      },
-      "source": [
-        "`curl` is a package for downloading files off the internet.\n",
-        "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
-        "This file is also in the github repo, you can look at it there if you want.\n",
-        "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
-        "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Kjo3hTS_ARAu",
-        "outputId": "552163ed-0b63-4895-8337-5b03e44fb881"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
-            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
-            "100  7248  100  7248    0     0  54291      0 --:--:-- --:--:-- --:--:--     0--:-- --:--:-- --:--:-- 54496\n"
-          ]
-        }
-      ],
-      "source": [
-        "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {
-        "id": "MKc8rBCmARAu"
-      },
-      "outputs": [],
-      "source": [
-        "# Now we'll import the different classes from this new file\n",
-        "# Import the dataloader and dataset classes\n",
-        "from challenge_utilities import SkyDataset # Dataset object itself\n",
-        "# A subclass of torch.utils.data.Dataset\n",
-        "from challenge_utilities import SkyGenerator # Generic dataloader object, same for all challenges\n",
-        "from challenge_utilities import Eval"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {
-        "id": "2IXmuM_EARAv"
-      },
-      "outputs": [],
-      "source": [
-        "# Standard packages\n",
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "import torch\n",
-        "import torchvision\n",
-        "from torchsummary import summary"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "W9XZQhfDARAv"
-      },
-      "source": [
-        "#### Package documentation\n",
-        "\n",
-        "If you get stuck for syntax or anything - these are the packages used.\n",
-        "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
-        "\n",
-        "[MatPlotLib](https://matplotlib.org/)\n",
-        "\n",
-        "[Pytorch](https://docs.pytorch.org/docs/)\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "m5EFoTAgARAv"
-      },
-      "source": [
-        "# Exploratory Data Analysis\n",
-        "\n",
-        "Understanding your data is a critical part of any AI/ML project.\n",
-        "Make sure you look at your data and understand the differences between each class.\n",
-        "\n",
-        "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
-        "You can use this to label your plots."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 477
-        },
-        "id": "66Gal0ukARAv",
-        "outputId": "caed553d-8a96-4e5d-cee8-1b60be4310fe"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 9 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "\n",
-        "label_map = {\n",
-        "    0: \"Star\",\n",
-        "    1: \"Galaxy\"\n",
-        "}\n",
-        "\n",
-        "def plot_samples(generator, n_columns=3, n_rows=3, label_map:dict|None=None):\n",
-        "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
-        "    plt.tight_layout()\n",
-        "    plt.setp(subplots, xticks=[], yticks=[])\n",
-        "\n",
-        "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
-        "        image, label = generator.get(sample_index)\n",
-        "        subplot.imshow(image.squeeze())\n",
-        "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
-        "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-        "\n",
-        "        string_label = label_map[label.item()] if label_map else str(label.item())\n",
-        "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-        "\n",
-        "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
-        "plot_samples(samples, label_map=label_map)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "VTG-xMYWARAw"
-      },
-      "source": [
-        "# Look at the input data\n",
-        "\n",
-        "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 4,
-      "metadata": {
-        "id": "6FJGVsZgARAw"
-      },
-      "outputs": [],
-      "source": [
-        "# These two generators produce the data we'll train with\n",
-        "\n",
-        "n_train_samples = 1280\n",
-        "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
-        "\n",
-        "n_val_samples = 1280\n",
-        "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 5,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 470
-        },
-        "id": "KM_sOu9sARAw",
-        "outputId": "92e2f0b1-4808-49d4-9049-67a799d21ca6"
-      },
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "Text(0.5, 1.0, 'Val labels')"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 5
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 2 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
-        "\n",
-        "fig, ax = plt.subplots(1,2)\n",
-        "ax[0].hist(train_generator.dataset.labels)\n",
-        "ax[0].set_title(\"Train labels\")\n",
-        "ax[1].hist(val_generator.dataset.labels)\n",
-        "ax[1].set_title(\"Val labels\")\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 6,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 449
-        },
-        "id": "TwAsJhDMARAw",
-        "outputId": "4899a0d7-1e6e-41c7-ca20-47fafb717a9a"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 2 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "# We can also look at different attributes of the images\n",
-        "# Here, let's look at max values and mean values\n",
-        "\n",
-        "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
-        "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-        "\n",
-        "# Normally we would also have some metadata to work with, but here we only have images\n",
-        "\n",
-        "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
-        "\n",
-        "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
-        "\n",
-        "figure, subplots = plt.subplots(1, 2)\n",
-        "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
-        "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
-        "subplots[0].legend()\n",
-        "subplots[0].set_xlabel(\"Mean pixel value\")\n",
-        "\n",
-        "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
-        "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
-        "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
-        "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
-        "subplots[1].set_xlabel(\"Max pixel value\")\n",
-        "\n",
-        "\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "NhRpPEjdARAw"
-      },
-      "source": [
-        "## Data Processing\n",
-        "\n",
-        "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-        "There are near infinite ways to pre-process, especially in the computer vision space.\n",
-        "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
-        "\n",
-        "For this, let's try bringing all the pixels in the image between 0 and 1."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 9,
-      "metadata": {
-        "id": "Wp_k5XTiARAw"
-      },
-      "outputs": [],
-      "source": [
-        "# Torch uses \"transforms\" to apply a series of transforms to the data as its being loaded\n",
-        "# We can define this as a set of transforms we can apply either as part of the dataloader,\n",
-        "# or as a separate step after loading the data.\n",
-        "\n",
-        "transforms = torchvision.transforms.Compose([\n",
-        "    torchvision.transforms.Resize((64, 64)), # Resize the images to 64 x 64 pixels\n",
-        "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
-        "])\n",
-        "\n",
-        "# We can apply other transforms, in a process called \"data augmentation\"\n",
-        "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
-        "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 13,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "id": "6gXn05XNARAx",
-        "outputId": "32dbf946-86b8-419a-a03e-8fd4d893158f"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "# Look at some processed samples!\n",
-        "\n",
-        "n_samples = 9\n",
-        "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
-        "for image, label in samples:\n",
-        "    image = transforms(image)\n",
-        "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
-        "    plt.xlabel(label_map[label.item()])\n",
-        "    plt.show()\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "HJEKKWHpARAx"
-      },
-      "source": [
-        "## Make the binary classification model\n",
-        "\n",
-        "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
-        "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
-        "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
-        "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
-        "\n",
-        "In this case, what we want:\n",
-        "* Take the input images from the data generator\n",
-        "* Apply two convolutional blocks to the input image\n",
-        "* Decode the second convolution block's output to a probability of the image being a given class."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 40,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "yb6L7SDoARAx",
-        "outputId": "4a606080-485d-4ca0-b451-6f125eea10c2"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "----------------------------------------------------------------\n",
-            "        Layer (type)               Output Shape         Param #\n",
-            "================================================================\n",
-            "            Conv2d-1           [-1, 16, 64, 64]             160\n",
-            "              ReLU-2           [-1, 16, 64, 64]               0\n",
-            "         MaxPool2d-3           [-1, 16, 32, 32]               0\n",
-            "            Conv2d-4           [-1, 32, 32, 32]           4,640\n",
-            "              ReLU-5           [-1, 32, 32, 32]               0\n",
-            "         MaxPool2d-6           [-1, 32, 16, 16]               0\n",
-            "            Conv2d-7           [-1, 64, 16, 16]          18,496\n",
-            "              ReLU-8           [-1, 64, 16, 16]               0\n",
-            "         MaxPool2d-9             [-1, 64, 8, 8]               0\n",
-            "           Linear-10                  [-1, 128]         524,416\n",
-            "             ReLU-11                  [-1, 128]               0\n",
-            "          Dropout-12                  [-1, 128]               0\n",
-            "           Linear-13                    [-1, 1]             129\n",
-            "================================================================\n",
-            "Total params: 547,841\n",
-            "Trainable params: 547,841\n",
-            "Non-trainable params: 0\n",
-            "----------------------------------------------------------------\n",
-            "Input size (MB): 0.02\n",
-            "Forward/backward pass size (MB): 1.97\n",
-            "Params size (MB): 2.09\n",
-            "Estimated Total Size (MB): 4.08\n",
-            "----------------------------------------------------------------\n",
-            "None\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Create a simple convolusional model\n",
-        "\n",
-        "class SimpleCNN(torch.nn.Module):\n",
-        "    def __init__(self):\n",
-        "      super().__init__()\n",
-        "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
-        "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
-        "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
-        "\n",
-        "      # Pooling layer\n",
-        "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
-        "\n",
-        "      # Fully connected layers\n",
-        "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
-        "      # 64 channels * 8x8 = 4096 input features\n",
-        "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
-        "      self.fc2 = torch.nn.Linear(128, 1)\n",
-        "\n",
-        "      # Dropout\n",
-        "      self.dropout = torch.nn.Dropout(0.3)\n",
-        "\n",
-        "      # Activation\n",
-        "      self.relu = torch.nn.ReLU()\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
-        "      if x.dim() == 3:\n",
-        "          x = x.unsqueeze(1)  # Now (batch_size, 1, 64, 64)\n",
-        "\n",
-        "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
-        "      x = self.pool(self.relu(self.conv1(x)))\n",
-        "\n",
-        "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
-        "      x = self.pool(self.relu(self.conv2(x)))\n",
-        "\n",
-        "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
-        "      x = self.pool(self.relu(self.conv3(x)))\n",
-        "\n",
-        "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
-        "      x = x.view(x.size(0), -1)\n",
-        "\n",
-        "      # Fully connected layers\n",
-        "      x = self.relu(self.fc1(x))\n",
-        "      x = self.dropout(x)\n",
-        "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
-        "\n",
-        "      return torch.softmax(x.squeeze(), 0) # Output of (batch_size)\n",
-        "\n",
-        "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "NqOS_59-ARAy"
-      },
-      "source": [
-        "## Training process\n",
-        "\n",
-        "Based on the previous lessons, we know we need a few things to train a model\n",
-        "\n",
-        "### Loss and Optimizer\n",
-        "\n",
-        "\n",
-        "### Training and Validation data loops\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 31,
-      "metadata": {
-        "id": "CPJDwFxSARAy"
-      },
-      "outputs": [],
-      "source": [
-        "# Random choices of optimizer and loss functions\n",
-        "# These are pretty standard for classification\n",
-        "optimizer = torch.optim.Adam(SimpleCNN().parameters(), lr=0.001)\n",
-        "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)\n",
-        "\n"
-      ]
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jToNcYCsARAt"
+   },
+   "source": [
+    "## Model Training Challenge!\n",
+    "\n",
+    "In this notebook, there are a whole host of weird errors.\n",
+    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+    "Do your best to sniff out the mistakes in both code and training procedure!\n",
+    "\n",
+    "Your mission, should you choose to accept it, is:\n",
+    "* Work together in groups of 4 to complete this notebook\n",
+    "* Figure out all the coding mistakes and make a notebook that runs\n",
+    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RX8h5B-GARAt"
+   },
+   "source": [
+    "This line below installs a non-standard data generation package.\n",
+    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+    "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "6XyF3QGjARAy"
-      },
-      "source": [
-        "# Train the model\n",
-        "\n",
-        "We have all the pieces in place:\n",
-        "- [x] Model\n",
-        "- [x] Train Data\n",
-        "- [x] Validation Data\n",
-        "- [x] Loss Function\n",
-        "- [x] Optimizer"
-      ]
+    "id": "VPUeGpTrARAu",
+    "outputId": "742b2828-b17a-445a-bc57-327fa506f61a"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install deepbench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xatOAXZ6ARAu"
+   },
+   "source": [
+    "`curl` is a package for downloading files off the internet.\n",
+    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+    "This file is also in the github repo, you can look at it there if you want.\n",
+    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Kjo3hTS_ARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MKc8rBCmARAu"
+   },
+   "outputs": [],
+   "source": [
+    "# Now we'll import the different classes from this new file\n",
+    "# Import the dataloader and dataset classes\n",
+    "from challenge_utilities import SkyDataset, TestDataset # Dataset object itself\n",
+    "# A subclass of torch.utils.data.Dataset\n",
+    "from challenge_utilities import SkyGenerator # Generic dataloader object, same for all challenges\n",
+    "from challenge_utilities import Eval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2IXmuM_EARAv"
+   },
+   "outputs": [],
+   "source": [
+    "# Standard packages\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torch\n",
+    "import torchvision\n",
+    "from torchsummary import summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W9XZQhfDARAv"
+   },
+   "source": [
+    "#### Package documentation\n",
+    "\n",
+    "If you get stuck for syntax or anything - these are the packages used.\n",
+    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+    "\n",
+    "[MatPlotLib](https://matplotlib.org/)\n",
+    "\n",
+    "[Pytorch](https://docs.pytorch.org/docs/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m5EFoTAgARAv"
+   },
+   "source": [
+    "# Exploratory Data Analysis\n",
+    "\n",
+    "Understanding your data is a critical part of any AI/ML project.\n",
+    "Make sure you look at your data and understand the differences between each class.\n",
+    "\n",
+    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+    "You can use this to label your plots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 477
     },
-    {
-      "cell_type": "code",
-      "execution_count": 43,
-      "metadata": {
-        "id": "adEJ4vhuARAy"
-      },
-      "outputs": [],
-      "source": [
-        "\n",
-        "def train_epoch(model, dataloader, optimizer, criterion):\n",
-        "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
-        "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
-        "    n_batches = len(dataloader)\n",
-        "    for images, labels in dataloader:\n",
-        "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
-        "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
-        "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
-        "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
-        "      optimizer.step() # Update the model parameters using the computed gradients\n",
-        "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
-        "\n",
-        "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
-        "\n",
-        "\n",
-        "def val_epoch(model, dataloader, criterion):\n",
-        "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
-        "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
-        "    n_batches = len(dataloader)\n",
-        "    with torch.no_grad(): # Disable gradient computation for validation\n",
-        "        for images, labels in dataloader:\n",
-        "            outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
-        "            loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
-        "            batch_loss += loss.item() # Accumulate the loss for this batch\n",
-        "\n",
-        "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
-        "\n",
-        "\n",
-        "n_epochs = 10\n",
-        "model = SimpleCNN()\n",
-        "loss_history = {\"train\": [], \"val\": []}\n",
-        "for epoch in range(n_epochs):\n",
-        "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
-        "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
-        "    loss_history[\"train\"].append(train_loss)\n",
-        "    loss_history[\"val\"].append(val_loss)\n",
-        "\n"
-      ]
+    "id": "66Gal0ukARAv",
+    "outputId": "8ccd7889-72d1-4fce-f6c7-a417d7515a7b"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "label_map = {\n",
+    "    0: \"Star\",\n",
+    "    1: \"Galaxy\"\n",
+    "}\n",
+    "\n",
+    "def plot_samples(generator, n_columns=3, n_rows=3, label_map:dict|None=None):\n",
+    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+    "    plt.tight_layout()\n",
+    "    plt.setp(subplots, xticks=[], yticks=[])\n",
+    "\n",
+    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+    "        image, label = generator.get(sample_index)\n",
+    "        subplot.imshow(image.squeeze())\n",
+    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+    "\n",
+    "        string_label = label_map[label.item()] if label_map else str(label.item())\n",
+    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+    "\n",
+    "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+    "plot_samples(samples, label_map=label_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VTG-xMYWARAw"
+   },
+   "source": [
+    "# Look at the input data\n",
+    "\n",
+    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6FJGVsZgARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# These two generators produce the data we'll train with\n",
+    "\n",
+    "n_train_samples = 1280\n",
+    "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+    "\n",
+    "n_val_samples = 1280\n",
+    "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 470
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "3QCcxf0dARAy"
-      },
-      "source": [
-        "## Model Evaluation\n",
-        "\n",
-        "There are some steps we can take to see how well a model trained.\n",
-        "\n",
-        "### Loss Plots\n",
-        "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
-        "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
-        "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
-      ]
+    "id": "KM_sOu9sARAw",
+    "outputId": "25602dc3-05cb-4784-c5a5-295eaa9ea0a1"
+   },
+   "outputs": [],
+   "source": [
+    "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+    "\n",
+    "fig, ax = plt.subplots(1,2)\n",
+    "ax[0].hist(train_generator.dataset.labels)\n",
+    "ax[0].set_title(\"Train labels\")\n",
+    "ax[1].hist(val_generator.dataset.labels)\n",
+    "ax[1].set_title(\"Val labels\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 449
     },
-    {
-      "cell_type": "code",
-      "execution_count": 44,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 472
-        },
-        "id": "pfDIpqHGARAy",
-        "outputId": "1ed28344-a60a-4792-c3bd-77ce7551f2a2"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
-        "# Eval.plot_history is a simple function\n",
-        "# plots the loss as a function of epoch"
-      ]
+    "id": "TwAsJhDMARAw",
+    "outputId": "8438e12f-1aae-4b70-96b1-91510f8ee1b6"
+   },
+   "outputs": [],
+   "source": [
+    "# We can also look at different attributes of the images\n",
+    "# Here, let's look at max values and mean values\n",
+    "\n",
+    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+    "\n",
+    "# Normally we would also have some metadata to work with, but here we only have images\n",
+    "\n",
+    "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "figure, subplots = plt.subplots(1, 2)\n",
+    "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[0].legend()\n",
+    "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+    "\n",
+    "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+    "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+    "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[1].set_xlabel(\"Max pixel value\")\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NhRpPEjdARAw"
+   },
+   "source": [
+    "## Data Processing\n",
+    "\n",
+    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+    "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+    "\n",
+    "For this, let's try bringing all the pixels in the image between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wp_k5XTiARAw"
+   },
+   "outputs": [],
+   "source": [
+    "transforms = torchvision.transforms.Compose([\n",
+    "    torchvision.transforms.Resize((64, 64)), # Resize the images to 64 x 64 pixels\n",
+    "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+    "])\n",
+    "\n",
+    "# We can apply other transforms, in a process called \"data augmentation\"\n",
+    "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+    "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "V_9R4WYqARAy"
-      },
-      "source": [
-        "## Classification Accuracy Plots\n",
-        "\n",
-        "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
-        "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
-        "\n",
-        "### ROC\n",
-        "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
-        "It shows how likely a model is to correctly predict something.\n",
-        "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
-        "\n",
-        "\n",
-        "### Confusion Matrix\n",
-        "\n",
-        "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
-        "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
-        "It plots the rate of predicted values for a given class versus the true values.\n",
-        "\n",
-        " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
-      ]
+    "id": "6gXn05XNARAx",
+    "outputId": "76322868-6110-4b6f-8dd4-7b8a9acca378"
+   },
+   "outputs": [],
+   "source": [
+    "# Look at some processed samples!\n",
+    "\n",
+    "n_samples = 9\n",
+    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+    "for image, label in samples:\n",
+    "    image = transforms(image)\n",
+    "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+    "    plt.xlabel(label_map[label.item()])\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HJEKKWHpARAx"
+   },
+   "source": [
+    "## Make the binary classification model\n",
+    "\n",
+    "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+    "\n",
+    "In this case, what we want:\n",
+    "* Take the input images from the data generator\n",
+    "* Apply two convolutional blocks to the input image\n",
+    "* Decode the second convolution block's output to a probability of the image being a given class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
-    {
-      "cell_type": "code",
-      "execution_count": 46,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 313
-        },
-        "id": "iP_xgNcMARAy",
-        "outputId": "e34e8613-39fb-4235-afc0-4465b1315fab"
-      },
-      "outputs": [
-        {
-          "output_type": "error",
-          "ename": "AttributeError",
-          "evalue": "'numpy.ndarray' object has no attribute 'float'",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-            "\u001b[0;32m/tmp/ipykernel_40524/3837159380.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mprediction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmake_prediction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_generator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-            "\u001b[0;32m/tmp/ipykernel_40524/3837159380.py\u001b[0m in \u001b[0;36mtest_quality\u001b[0;34m(prediction, labels)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest_quality\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprediction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m     \u001b[0maccuracy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprediction\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Compute the accuracy by comparing the predicted classes to the true labels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0maccuracy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'float'"
-          ]
-        }
-      ],
-      "source": [
-        "test_generator = SkyGenerator(n_samples=1280, dataset=SkyDataset, shuffle=True, transform=transforms)\n",
-        "\n",
-        "def make_prediction(model, test_generator):\n",
-        "    prediction_classes = []\n",
-        "    for images, _ in test_generator.get_dataloader():\n",
-        "        predictions = model(transforms(images))\n",
-        "        prediction_classes += torch.where(predictions<0.5, 0, 1)\n",
-        "    labels = test_generator.dataset.labels\n",
-        "\n",
-        "\n",
-        "    return prediction_classes, labels\n",
-        "\n",
-        "def test_quality(prediction, labels):\n",
-        "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
-        "    return accuracy.numpy()\n",
-        "\n",
-        "prediction, labels = make_prediction(model, test_generator)\n",
-        "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-      ]
+    "id": "yb6L7SDoARAx",
+    "outputId": "7765d938-5f7b-4e41-8ac3-a35aa79663f4"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a simple convolusional model\n",
+    "\n",
+    "class SimpleCNN(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "      super().__init__()\n",
+    "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+    "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "\n",
+    "      # Pooling layer\n",
+    "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+    "      # 64 channels * 8x8 = 4096 input features\n",
+    "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+    "      self.fc2 = torch.nn.Linear(128, 1)\n",
+    "\n",
+    "      # Dropout\n",
+    "      self.dropout = torch.nn.Dropout(0.3)\n",
+    "\n",
+    "      # Activation\n",
+    "      self.relu = torch.nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+    "      if x.dim() == 3:\n",
+    "          x = x.unsqueeze(1)  # Now (batch_size, 1, 64, 64)\n",
+    "\n",
+    "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+    "      x = self.pool(self.relu(self.conv1(x)))\n",
+    "\n",
+    "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+    "      x = self.pool(self.relu(self.conv2(x)))\n",
+    "\n",
+    "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+    "      x = self.pool(self.relu(self.conv3(x)))\n",
+    "\n",
+    "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+    "      x = x.view(x.size(0), -1)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      x = self.relu(self.fc1(x))\n",
+    "      x = self.dropout(x)\n",
+    "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+    "\n",
+    "      return torch.sigmoid(x.squeeze()) # Output of (batch_size)\n",
+    "\n",
+    "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NqOS_59-ARAy"
+   },
+   "source": [
+    "## Training process\n",
+    "\n",
+    "Based on the previous lessons, we know we need a few things to train a model\n",
+    "\n",
+    "### Loss and Optimizer\n",
+    "\n",
+    "\n",
+    "### Training and Validation data loops\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "CPJDwFxSARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize the model once\n",
+    "model = SimpleCNN()\n",
+    "\n",
+    "# Random choices of optimizer and loss functions\n",
+    "# These are pretty standard for classification\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
+    "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6XyF3QGjARAy"
+   },
+   "source": [
+    "# Train the model\n",
+    "\n",
+    "We have all the pieces in place:\n",
+    "- [x] Model\n",
+    "- [x] Train Data\n",
+    "- [x] Validation Data\n",
+    "- [x] Loss Function\n",
+    "- [x] Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "5f5Q78_IARAy",
-        "outputId": "17227148-f746-4a06-a93e-2c8acf4ba7fb"
-      },
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        },
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "# And now run them on your own data!\n",
-        "Eval.ROC_curve(prediction, labels)\n",
-        "Eval.confusion_matrix(prediction, labels)"
-      ]
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "base",
-      "language": "python",
-      "name": "python3"
+    "id": "adEJ4vhuARAy",
+    "outputId": "7856e742-8fb6-4956-bd34-61eab42495b0"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def train_epoch(model, dataloader, optimizer, criterion):\n",
+    "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Training...\")\n",
+    "    for images, labels in iterer:\n",
+    "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+    "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+    "      optimizer.step() # Update the model parameters using the computed gradients\n",
+    "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "      iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "\n",
+    "def val_epoch(model, dataloader, criterion):\n",
+    "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Validating...\")\n",
+    "    with torch.no_grad(): # Disable gradient computation for validation\n",
+    "        for images, labels in iterer:\n",
+    "            outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "            loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "            batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "            iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "# One epoch should take around 15 seconds\n",
+    "# The number of epochs is depednent on the complexity and size of your data\n",
+    "n_epochs = 30\n",
+    "loss_history = {\"train\": [], \"val\": []}\n",
+    "for epoch in range(n_epochs):\n",
+    "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+    "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+    "\n",
+    "    loss_history[\"train\"].append(train_loss)\n",
+    "    loss_history[\"val\"].append(val_loss)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3QCcxf0dARAy"
+   },
+   "source": [
+    "## Model Evaluation\n",
+    "\n",
+    "There are some steps we can take to see how well a model trained.\n",
+    "\n",
+    "### Loss Plots\n",
+    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 472
     },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.11.13"
+    "id": "pfDIpqHGARAy",
+    "outputId": "a9aa0f30-8e10-47d6-f4c2-d5b5682bb392"
+   },
+   "outputs": [],
+   "source": [
+    "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+    "# Eval.plot_history is a simple function\n",
+    "# plots the loss as a function of epoch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V_9R4WYqARAy"
+   },
+   "source": [
+    "## Classification Accuracy Plots\n",
+    "\n",
+    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+    "\n",
+    "### ROC\n",
+    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+    "It shows how likely a model is to correctly predict something.\n",
+    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+    "\n",
+    "\n",
+    "### Confusion Matrix\n",
+    "\n",
+    "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+    "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+    "It plots the rate of predicted values for a given class versus the true values.\n",
+    "\n",
+    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
-    "orig_nbformat": 4,
+    "id": "iP_xgNcMARAy",
+    "outputId": "62e30e98-f5f6-4b42-ab56-bd876d6d7e2d"
+   },
+   "outputs": [],
+   "source": [
+    "test_generator = SkyGenerator(n_samples=1280, dataset=TestDataset, shuffle=True).get_dataloader()\n",
+    "\n",
+    "def make_prediction(model, test_generator):\n",
+    "    predictions = []\n",
+    "    labels = []\n",
+    "    for image, label in test_generator:\n",
+    "        predictions += model(transforms(image))\n",
+    "        labels += label\n",
+    "    prediction_classes = torch.where(torch.tensor(predictions)<0.5, 0, 1)\n",
+    "    labels = torch.tensor(labels)\n",
+    "    return prediction_classes, labels\n",
+    "\n",
+    "def test_quality(prediction, labels):\n",
+    "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+    "    return accuracy.numpy()\n",
+    "\n",
+    "prediction, labels = make_prediction(model, test_generator)\n",
+    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
     "colab": {
-      "provenance": []
-    }
+     "base_uri": "https://localhost:8080/",
+     "height": 927
+    },
+    "id": "5f5Q78_IARAy",
+    "outputId": "0dc23cc1-33b8-46d1-bf97-bee6523531bc"
+   },
+   "outputs": [],
+   "source": [
+    "# And now run them on your own data!\n",
+    "Eval.ROC_curve(prediction, labels)\n",
+    "Eval.confusion_matrix(prediction, labels)"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
   },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}
\ No newline at end of file
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

From eb7f11606768fdf729ec413865ec8783ced23aaa Mon Sep 17 00:00:00 2001
From: voetberg <magpie127@gmail.com>
Date: Fri, 8 May 2026 15:05:00 -0500
Subject: [PATCH 3/3] Updated changes to use new notebook, updated README links

---
 Challenge/README.md                     |  10 +-
 Challenge/challenges/challenge01.ipynb  | 604 ++++++++++++++++++++++++
 Challenge/challenges/challenge02.ipynb  | 604 ++++++++++++++++++++++++
 Challenge/challenges/challenge03.ipynb  | 604 ++++++++++++++++++++++++
 Challenge/challenges/challenge04.ipynb  | 604 ++++++++++++++++++++++++
 Challenge/challenges/challenge05.ipynb  | 604 ++++++++++++++++++++++++
 Challenge/challenges/challenge_01.ipynb | 493 -------------------
 Challenge/challenges/challenge_02.ipynb | 502 --------------------
 Challenge/challenges/challenge_03.ipynb | 540 ---------------------
 Challenge/challenges/challenge_04.ipynb | 499 --------------------
 Challenge/challenges/challenge_05.ipynb | 501 --------------------
 11 files changed, 3025 insertions(+), 2540 deletions(-)
 create mode 100644 Challenge/challenges/challenge01.ipynb
 create mode 100644 Challenge/challenges/challenge02.ipynb
 create mode 100644 Challenge/challenges/challenge03.ipynb
 create mode 100644 Challenge/challenges/challenge04.ipynb
 create mode 100644 Challenge/challenges/challenge05.ipynb
 delete mode 100644 Challenge/challenges/challenge_01.ipynb
 delete mode 100644 Challenge/challenges/challenge_02.ipynb
 delete mode 100644 Challenge/challenges/challenge_03.ipynb
 delete mode 100644 Challenge/challenges/challenge_04.ipynb
 delete mode 100644 Challenge/challenges/challenge_05.ipynb

diff --git a/Challenge/README.md b/Challenge/README.md
index a378107..b543e1d 100644
--- a/Challenge/README.md
+++ b/Challenge/README.md
@@ -5,11 +5,11 @@ The no-save notebook links are here:
 
 | Challenge Number | Notebook |
 | ------------- |-------------| 
-| 1  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials_2025/blob/main/Challenge/challenges/challenge_01.ipynb) |
-| 2  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials_2025/blob/main/Challenge/challenges/challenge_02.ipynb) |
-| 3  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials_2025/blob/main/Challenge/challenges/challenge_03.ipynb) |
-| 4  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials_2025/blob/main/Challenge/challenges/challenge_04.ipynb) |
-| 5  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials_2025/blob/main/Challenge/challenges/challenge_05.ipynb) |
+| 1  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials/blob/main/Challenge/challenges/challenge01.ipynb) |
+| 2  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials/blob/main/Challenge/challenges/challenge02.ipynb) |
+| 3  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials/blob/main/Challenge/challenges/challenge03.ipynb) |
+| 4  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials/blob/main/Challenge/challenges/challenge04.ipynb) |
+| 5  | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BNL-Fermilab-RENEW/tutorials/blob/main/Challenge/challenges/challenge05.ipynb) |
 
 
 At the end of the challenge, you will have to present your work. 
diff --git a/Challenge/challenges/challenge01.ipynb b/Challenge/challenges/challenge01.ipynb
new file mode 100644
index 0000000..32e8370
--- /dev/null
+++ b/Challenge/challenges/challenge01.ipynb
@@ -0,0 +1,604 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jToNcYCsARAt"
+   },
+   "source": [
+    "## Model Training Challenge!\n",
+    "\n",
+    "In this notebook, there are a whole host of weird errors.\n",
+    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+    "Do your best to sniff out the mistakes in both code and training procedure!\n",
+    "\n",
+    "Your mission, should you choose to accept it, is:\n",
+    "* Work together in groups of 4 to complete this notebook\n",
+    "* Figure out all the coding mistakes and make a notebook that runs\n",
+    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RX8h5B-GARAt"
+   },
+   "source": [
+    "This line below installs a non-standard data generation package.\n",
+    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+    "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VPUeGpTrARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install deepbench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xatOAXZ6ARAu"
+   },
+   "source": [
+    "`curl` is a package for downloading files off the internet.\n",
+    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+    "This file is also in the github repo, you can look at it there if you want.\n",
+    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Kjo3hTS_ARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MKc8rBCmARAu"
+   },
+   "outputs": [],
+   "source": [
+    "# Now we'll import the different classes from this new file\n",
+    "# Import the dataloader and dataset classes\n",
+    "from challenge_utilities import SkaiDataset01 as SkyDataset # Dataset object itself\n",
+    "# A subclass of torch.utils.data.Dataset\n",
+    "from challenge_utilities import SkyGenerator, TestDataset # Generic dataloader object, same for all challenges\n",
+    "from challenge_utilities import Eval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2IXmuM_EARAv"
+   },
+   "outputs": [],
+   "source": [
+    "# Standard packages\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torchvision\n",
+    "from torchsummary import summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W9XZQhfDARAv"
+   },
+   "source": [
+    "#### Package documentation\n",
+    "\n",
+    "If you get stuck for syntax or anything - these are the packages used.\n",
+    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+    "\n",
+    "[MatPlotLib](https://matplotlib.org/)\n",
+    "\n",
+    "[Pytorch](https://docs.pytorch.org/docs/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m5EFoTAgARAv"
+   },
+   "source": [
+    "# Exploratory Data Analysis\n",
+    "\n",
+    "Understanding your data is a critical part of any AI/ML project.\n",
+    "Make sure you look at your data and understand the differences between each class.\n",
+    "\n",
+    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+    "You can use this to label your plots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "66Gal0ukARAv"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "label_map = {\n",
+    "    0: \"Star\",\n",
+    "    1: \"Galaxy\"\n",
+    "}\n",
+    "\n",
+    "def plot_samples(generator, n_columns=3, n_rows=6, label_map:dict|None=None):\n",
+    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+    "    plt.tight_layout()\n",
+    "    plt.setp(subplots, xticks=[], yticks=[])\n",
+    "\n",
+    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+    "        image, label = generator.get(sample_index)\n",
+    "        subplot.imshow(image)\n",
+    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+    "\n",
+    "        string_label = \"??????\"\n",
+    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+    "\n",
+    "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+    "plot_samples(samples, label_map=label_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VTG-xMYWARAw"
+   },
+   "source": [
+    "# Look at the input data\n",
+    "\n",
+    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6FJGVsZgARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# These two generators produce the data we'll train with\n",
+    "\n",
+    "n_train_samples = 20\n",
+    "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+    "\n",
+    "n_val_samples = 1280\n",
+    "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KM_sOu9sARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+    "\n",
+    "fig, ax = plt.subplots(1,2)\n",
+    "ax[0].hist(train_generator.dataset.labels)\n",
+    "ax[0].set_title(\"Train labels\")\n",
+    "ax[1].hist(val_generator.dataset.labels)\n",
+    "ax[1].set_title(\"Val labels\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TwAsJhDMARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# We can also look at different attributes of the images\n",
+    "# Here, let's look at max values and mean values\n",
+    "\n",
+    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+    "\n",
+    "# Normally we would also have some metadata to work with, but here we only have images\n",
+    "\n",
+    "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "figure, subplots = plt.subplots(1, 2)\n",
+    "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[0].legend()\n",
+    "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+    "\n",
+    "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+    "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+    "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[1].set_xlabel(\"Max pixel value\")\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NhRpPEjdARAw"
+   },
+   "source": [
+    "## Data Processing\n",
+    "\n",
+    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+    "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+    "\n",
+    "For this, let's try bringing all the pixels in the image between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wp_k5XTiARAw"
+   },
+   "outputs": [],
+   "source": [
+    "transforms = torchvision.transforms.Compose([\n",
+    "    torchvision.transforms.RandomResizedCrop(32, 164), # Resize the images to 64 x 64 pixels\n",
+    "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+    "])\n",
+    "\n",
+    "# We can apply other transforms, in a process called \"data augmentation\"\n",
+    "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+    "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6gXn05XNARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Look at some processed samples!\n",
+    "\n",
+    "n_samples = 9\n",
+    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+    "for image, label in samples:\n",
+    "    image = transforms(image)\n",
+    "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+    "    plt.xlabel(label_map[label.item()])\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HJEKKWHpARAx"
+   },
+   "source": [
+    "## Make the binary classification model\n",
+    "\n",
+    "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+    "\n",
+    "In this case, what we want:\n",
+    "* Take the input images from the data generator\n",
+    "* Apply two convolutional blocks to the input image\n",
+    "* Decode the second convolution block's output to a probability of the image being a given class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yb6L7SDoARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a simple convolusional model\n",
+    "\n",
+    "class SimpleCNN(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "      super().__init__()\n",
+    "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+    "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "\n",
+    "      # Pooling layer\n",
+    "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+    "      # 64 channels * 8x8 = 4096 input features\n",
+    "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+    "      self.fc2 = torch.nn.Linear(128, 1)\n",
+    "\n",
+    "      # Dropout\n",
+    "      self.dropout = torch.nn.Dropout(0.3)\n",
+    "\n",
+    "      # Activation\n",
+    "      self.relu = torch.nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+    "      if x.dim() == 3:\n",
+    "          \"???\"\n",
+    "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+    "      x = self.pool(self.relu(self.conv1(x)))\n",
+    "\n",
+    "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+    "      x = self.pool(self.relu(self.conv2(x)))\n",
+    "\n",
+    "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+    "\n",
+    "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+    "      x = x.view(x.size(0), -1)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      x = self.relu(self.fc1(x))\n",
+    "      x = self.dropout(x)\n",
+    "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+    "\n",
+    "      return torch.softmax(x.squeeze()) # Output of (batch_size)\n",
+    "\n",
+    "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NqOS_59-ARAy"
+   },
+   "source": [
+    "## Training process\n",
+    "\n",
+    "Based on the previous lessons, we know we need a few things to train a model\n",
+    "\n",
+    "### Loss and Optimizer\n",
+    "\n",
+    "\n",
+    "### Training and Validation data loops\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "CPJDwFxSARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize the model once\n",
+    "model = SimpleCNN()\n",
+    "\n",
+    "# Random choices of optimizer and loss functions\n",
+    "# These are pretty standard for classification\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
+    "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6XyF3QGjARAy"
+   },
+   "source": [
+    "# Train the model\n",
+    "\n",
+    "We have all the pieces in place:\n",
+    "- [x] Model\n",
+    "- [x] Train Data\n",
+    "- [x] Validation Data\n",
+    "- [x] Loss Function\n",
+    "- [x] Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "adEJ4vhuARAy"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def train_epoch(model, dataloader, optimizer, criterion):\n",
+    "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Training...\")\n",
+    "    for images, labels in iterer:\n",
+    "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+    "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+    "      # Update the model parameters using the computed gradients\n",
+    "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "      iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "\n",
+    "def val_epoch(model, dataloader, criterion):\n",
+    "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Validating...\")\n",
+    "    # Disable gradient computation for validation\n",
+    "    for images, labels in iterer:\n",
+    "        outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "        loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "        batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "        iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "# One epoch should take around 15 seconds\n",
+    "# The number of epochs is depednent on the complexity and size of your data\n",
+    "n_epochs = 2\n",
+    "loss_history = {\"train\": [], \"val\": []}\n",
+    "for epoch in range(n_epochs):\n",
+    "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+    "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+    "\n",
+    "    loss_history[\"train\"].append(train_loss)\n",
+    "    loss_history[\"val\"].append(val_loss)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3QCcxf0dARAy"
+   },
+   "source": [
+    "## Model Evaluation\n",
+    "\n",
+    "There are some steps we can take to see how well a model trained.\n",
+    "\n",
+    "### Loss Plots\n",
+    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pfDIpqHGARAy"
+   },
+   "outputs": [],
+   "source": [
+    "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+    "# Eval.plot_history is a simple function\n",
+    "# plots the loss as a function of epoch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V_9R4WYqARAy"
+   },
+   "source": [
+    "## Classification Accuracy Plots\n",
+    "\n",
+    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+    "\n",
+    "### ROC\n",
+    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+    "It shows how likely a model is to correctly predict something.\n",
+    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+    "\n",
+    "\n",
+    "### Confusion Matrix\n",
+    "\n",
+    "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+    "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+    "It plots the rate of predicted values for a given class versus the true values.\n",
+    "\n",
+    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iP_xgNcMARAy"
+   },
+   "outputs": [],
+   "source": [
+    "test_generator = SkyGenerator(n_samples=1280, dataset=TestDataset, shuffle=True).get_dataloader()\n",
+    "\n",
+    "def make_prediction(model, test_generator):\n",
+    "    predictions = []\n",
+    "    labels = []\n",
+    "    for image, label in test_generator:\n",
+    "        predictions += model(transforms(image))\n",
+    "        labels += label\n",
+    "    prediction_classes = torch.where(torch.tensor(predictions)<0.5, 0, 1)\n",
+    "    labels = torch.tensor(labels)\n",
+    "    return prediction_classes, labels\n",
+    "\n",
+    "def test_quality(prediction, labels):\n",
+    "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+    "    return accuracy.numpy()\n",
+    "\n",
+    "prediction, labels = make_prediction(model, test_generator)\n",
+    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5f5Q78_IARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# And now run them on your own data!\n",
+    "Eval.ROC_curve(prediction, labels)\n",
+    "Eval.confusion_matrix(prediction, labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G671xYOV7yfd"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/Challenge/challenges/challenge02.ipynb b/Challenge/challenges/challenge02.ipynb
new file mode 100644
index 0000000..ba2959f
--- /dev/null
+++ b/Challenge/challenges/challenge02.ipynb
@@ -0,0 +1,604 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jToNcYCsARAt"
+   },
+   "source": [
+    "## Model Training Challenge!\n",
+    "\n",
+    "In this notebook, there are a whole host of weird errors.\n",
+    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+    "Do your best to sniff out the mistakes in both code and training procedure!\n",
+    "\n",
+    "Your mission, should you choose to accept it, is:\n",
+    "* Work together in groups of 4 to complete this notebook\n",
+    "* Figure out all the coding mistakes and make a notebook that runs\n",
+    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RX8h5B-GARAt"
+   },
+   "source": [
+    "This line below installs a non-standard data generation package.\n",
+    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+    "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VPUeGpTrARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install deepbench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xatOAXZ6ARAu"
+   },
+   "source": [
+    "`curl` is a package for downloading files off the internet.\n",
+    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+    "This file is also in the github repo, you can look at it there if you want.\n",
+    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Kjo3hTS_ARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MKc8rBCmARAu"
+   },
+   "outputs": [],
+   "source": [
+    "# Now we'll import the different classes from this new file\n",
+    "# Import the dataloader and dataset classes\n",
+    "from challenge_utilities import SkaiDataset02 as SkyDataset # Dataset object itself\n",
+    "# A subclass of torch.utils.data.Dataset\n",
+    "from challenge_utilities import SkyGenerator, TestDataset # Generic dataloader object, same for all challenges\n",
+    "from challenge_utilities import Eval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2IXmuM_EARAv"
+   },
+   "outputs": [],
+   "source": [
+    "# Standard packages\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torchvision\n",
+    "from torchsummary import summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W9XZQhfDARAv"
+   },
+   "source": [
+    "#### Package documentation\n",
+    "\n",
+    "If you get stuck for syntax or anything - these are the packages used.\n",
+    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+    "\n",
+    "[MatPlotLib](https://matplotlib.org/)\n",
+    "\n",
+    "[Pytorch](https://docs.pytorch.org/docs/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m5EFoTAgARAv"
+   },
+   "source": [
+    "# Exploratory Data Analysis\n",
+    "\n",
+    "Understanding your data is a critical part of any AI/ML project.\n",
+    "Make sure you look at your data and understand the differences between each class.\n",
+    "\n",
+    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+    "You can use this to label your plots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "66Gal0ukARAv"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "label_map = {\n",
+    "    0: \"Star\",\n",
+    "    1: \"Galaxy\"\n",
+    "}\n",
+    "\n",
+    "def plot_samples(generator, n_columns=3, n_rows=6, label_map:dict|None=None):\n",
+    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+    "    plt.tight_layout()\n",
+    "    plt.setp(subplots, xticks=[], yticks=[])\n",
+    "\n",
+    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+    "        image, label = generator.get(sample_index)\n",
+    "        subplot.imshow(image)\n",
+    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+    "\n",
+    "        string_label = \"??????\"\n",
+    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+    "\n",
+    "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+    "plot_samples(samples, label_map=label_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VTG-xMYWARAw"
+   },
+   "source": [
+    "# Look at the input data\n",
+    "\n",
+    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6FJGVsZgARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# These two generators produce the data we'll train with\n",
+    "\n",
+    "n_train_samples = 20\n",
+    "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+    "\n",
+    "n_val_samples = 1280\n",
+    "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KM_sOu9sARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+    "\n",
+    "fig, ax = plt.subplots(1,2)\n",
+    "ax[0].hist(train_generator.dataset.labels)\n",
+    "ax[0].set_title(\"Train labels\")\n",
+    "ax[1].hist(val_generator.dataset.labels)\n",
+    "ax[1].set_title(\"Val labels\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TwAsJhDMARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# We can also look at different attributes of the images\n",
+    "# Here, let's look at max values and mean values\n",
+    "\n",
+    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+    "\n",
+    "# Normally we would also have some metadata to work with, but here we only have images\n",
+    "\n",
+    "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "figure, subplots = plt.subplots(1, 2)\n",
+    "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[0].legend()\n",
+    "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+    "\n",
+    "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+    "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+    "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[1].set_xlabel(\"Max pixel value\")\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NhRpPEjdARAw"
+   },
+   "source": [
+    "## Data Processing\n",
+    "\n",
+    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+    "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+    "\n",
+    "For this, let's try bringing all the pixels in the image between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wp_k5XTiARAw"
+   },
+   "outputs": [],
+   "source": [
+    "transforms = torchvision.transforms.Compose([\n",
+    "    torchvision.transforms.RandomResizedCrop(32, 164), # Resize the images to 64 x 64 pixels\n",
+    "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+    "])\n",
+    "\n",
+    "# We can apply other transforms, in a process called \"data augmentation\"\n",
+    "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+    "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6gXn05XNARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Look at some processed samples!\n",
+    "\n",
+    "n_samples = 9\n",
+    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+    "for image, label in samples:\n",
+    "    image = transforms(image)\n",
+    "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+    "    plt.xlabel(label_map[label.item()])\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HJEKKWHpARAx"
+   },
+   "source": [
+    "## Make the binary classification model\n",
+    "\n",
+    "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+    "\n",
+    "In this case, what we want:\n",
+    "* Take the input images from the data generator\n",
+    "* Apply two convolutional blocks to the input image\n",
+    "* Decode the second convolution block's output to a probability of the image being a given class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yb6L7SDoARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a simple convolusional model\n",
+    "\n",
+    "class SimpleCNN(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "      super().__init__()\n",
+    "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+    "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "\n",
+    "      # Pooling layer\n",
+    "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+    "      # 64 channels * 8x8 = 4096 input features\n",
+    "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+    "      self.fc2 = torch.nn.Linear(128, 1)\n",
+    "\n",
+    "      # Dropout\n",
+    "      self.dropout = torch.nn.Dropout(0.3)\n",
+    "\n",
+    "      # Activation\n",
+    "      self.relu = torch.nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+    "      if x.dim() == 3:\n",
+    "          \"???\"\n",
+    "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+    "      x = self.pool(self.relu(self.conv1(x)))\n",
+    "\n",
+    "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+    "      x = self.pool(self.relu(self.conv2(x)))\n",
+    "\n",
+    "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+    "\n",
+    "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+    "      x = x.view(x.size(0), -1)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      x = self.relu(self.fc1(x))\n",
+    "      x = self.dropout(x)\n",
+    "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+    "\n",
+    "      return torch.softmax(x.squeeze()) # Output of (batch_size)\n",
+    "\n",
+    "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NqOS_59-ARAy"
+   },
+   "source": [
+    "## Training process\n",
+    "\n",
+    "Based on the previous lessons, we know we need a few things to train a model\n",
+    "\n",
+    "### Loss and Optimizer\n",
+    "\n",
+    "\n",
+    "### Training and Validation data loops\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "CPJDwFxSARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize the model once\n",
+    "model = SimpleCNN()\n",
+    "\n",
+    "# Random choices of optimizer and loss functions\n",
+    "# These are pretty standard for classification\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
+    "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6XyF3QGjARAy"
+   },
+   "source": [
+    "# Train the model\n",
+    "\n",
+    "We have all the pieces in place:\n",
+    "- [x] Model\n",
+    "- [x] Train Data\n",
+    "- [x] Validation Data\n",
+    "- [x] Loss Function\n",
+    "- [x] Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "adEJ4vhuARAy"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def train_epoch(model, dataloader, optimizer, criterion):\n",
+    "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Training...\")\n",
+    "    for images, labels in iterer:\n",
+    "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+    "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+    "      # Update the model parameters using the computed gradients\n",
+    "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "      iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "\n",
+    "def val_epoch(model, dataloader, criterion):\n",
+    "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Validating...\")\n",
+    "    # Disable gradient computation for validation\n",
+    "    for images, labels in iterer:\n",
+    "        outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "        loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "        batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "        iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "# One epoch should take around 15 seconds\n",
+    "# The number of epochs is depednent on the complexity and size of your data\n",
+    "n_epochs = 2\n",
+    "loss_history = {\"train\": [], \"val\": []}\n",
+    "for epoch in range(n_epochs):\n",
+    "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+    "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+    "\n",
+    "    loss_history[\"train\"].append(train_loss)\n",
+    "    loss_history[\"val\"].append(val_loss)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3QCcxf0dARAy"
+   },
+   "source": [
+    "## Model Evaluation\n",
+    "\n",
+    "There are some steps we can take to see how well a model trained.\n",
+    "\n",
+    "### Loss Plots\n",
+    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pfDIpqHGARAy"
+   },
+   "outputs": [],
+   "source": [
+    "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+    "# Eval.plot_history is a simple function\n",
+    "# plots the loss as a function of epoch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V_9R4WYqARAy"
+   },
+   "source": [
+    "## Classification Accuracy Plots\n",
+    "\n",
+    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+    "\n",
+    "### ROC\n",
+    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+    "It shows how likely a model is to correctly predict something.\n",
+    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+    "\n",
+    "\n",
+    "### Confusion Matrix\n",
+    "\n",
+    "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+    "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+    "It plots the rate of predicted values for a given class versus the true values.\n",
+    "\n",
+    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iP_xgNcMARAy"
+   },
+   "outputs": [],
+   "source": [
+    "test_generator = SkyGenerator(n_samples=1280, dataset=TestDataset, shuffle=True).get_dataloader()\n",
+    "\n",
+    "def make_prediction(model, test_generator):\n",
+    "    predictions = []\n",
+    "    labels = []\n",
+    "    for image, label in test_generator:\n",
+    "        predictions += model(transforms(image))\n",
+    "        labels += label\n",
+    "    prediction_classes = torch.where(torch.tensor(predictions)<0.5, 0, 1)\n",
+    "    labels = torch.tensor(labels)\n",
+    "    return prediction_classes, labels\n",
+    "\n",
+    "def test_quality(prediction, labels):\n",
+    "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+    "    return accuracy.numpy()\n",
+    "\n",
+    "prediction, labels = make_prediction(model, test_generator)\n",
+    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5f5Q78_IARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# And now run them on your own data!\n",
+    "Eval.ROC_curve(prediction, labels)\n",
+    "Eval.confusion_matrix(prediction, labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G671xYOV7yfd"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/Challenge/challenges/challenge03.ipynb b/Challenge/challenges/challenge03.ipynb
new file mode 100644
index 0000000..7250e29
--- /dev/null
+++ b/Challenge/challenges/challenge03.ipynb
@@ -0,0 +1,604 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jToNcYCsARAt"
+   },
+   "source": [
+    "## Model Training Challenge!\n",
+    "\n",
+    "In this notebook, there are a whole host of weird errors.\n",
+    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+    "Do your best to sniff out the mistakes in both code and training procedure!\n",
+    "\n",
+    "Your mission, should you choose to accept it, is:\n",
+    "* Work together in groups of 4 to complete this notebook\n",
+    "* Figure out all the coding mistakes and make a notebook that runs\n",
+    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RX8h5B-GARAt"
+   },
+   "source": [
+    "This line below installs a non-standard data generation package.\n",
+    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+    "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VPUeGpTrARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install deepbench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xatOAXZ6ARAu"
+   },
+   "source": [
+    "`curl` is a package for downloading files off the internet.\n",
+    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+    "This file is also in the github repo, you can look at it there if you want.\n",
+    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Kjo3hTS_ARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MKc8rBCmARAu"
+   },
+   "outputs": [],
+   "source": [
+    "# Now we'll import the different classes from this new file\n",
+    "# Import the dataloader and dataset classes\n",
+    "from challenge_utilities import SkaiDataset03 as SkyDataset # Dataset object itself\n",
+    "# A subclass of torch.utils.data.Dataset\n",
+    "from challenge_utilities import SkyGenerator, TestDataset # Generic dataloader object, same for all challenges\n",
+    "from challenge_utilities import Eval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2IXmuM_EARAv"
+   },
+   "outputs": [],
+   "source": [
+    "# Standard packages\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torchvision\n",
+    "from torchsummary import summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W9XZQhfDARAv"
+   },
+   "source": [
+    "#### Package documentation\n",
+    "\n",
+    "If you get stuck for syntax or anything - these are the packages used.\n",
+    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+    "\n",
+    "[MatPlotLib](https://matplotlib.org/)\n",
+    "\n",
+    "[Pytorch](https://docs.pytorch.org/docs/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m5EFoTAgARAv"
+   },
+   "source": [
+    "# Exploratory Data Analysis\n",
+    "\n",
+    "Understanding your data is a critical part of any AI/ML project.\n",
+    "Make sure you look at your data and understand the differences between each class.\n",
+    "\n",
+    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+    "You can use this to label your plots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "66Gal0ukARAv"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "label_map = {\n",
+    "    0: \"Star\",\n",
+    "    1: \"Galaxy\"\n",
+    "}\n",
+    "\n",
+    "def plot_samples(generator, n_columns=3, n_rows=6, label_map:dict|None=None):\n",
+    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+    "    plt.tight_layout()\n",
+    "    plt.setp(subplots, xticks=[], yticks=[])\n",
+    "\n",
+    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+    "        image, label = generator.get(sample_index)\n",
+    "        subplot.imshow(image)\n",
+    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+    "\n",
+    "        string_label = \"??????\"\n",
+    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+    "\n",
+    "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+    "plot_samples(samples, label_map=label_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VTG-xMYWARAw"
+   },
+   "source": [
+    "# Look at the input data\n",
+    "\n",
+    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6FJGVsZgARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# These two generators produce the data we'll train with\n",
+    "\n",
+    "n_train_samples = 20\n",
+    "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+    "\n",
+    "n_val_samples = 1280\n",
+    "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KM_sOu9sARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+    "\n",
+    "fig, ax = plt.subplots(1,2)\n",
+    "ax[0].hist(train_generator.dataset.labels)\n",
+    "ax[0].set_title(\"Train labels\")\n",
+    "ax[1].hist(val_generator.dataset.labels)\n",
+    "ax[1].set_title(\"Val labels\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TwAsJhDMARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# We can also look at different attributes of the images\n",
+    "# Here, let's look at max values and mean values\n",
+    "\n",
+    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+    "\n",
+    "# Normally we would also have some metadata to work with, but here we only have images\n",
+    "\n",
+    "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "figure, subplots = plt.subplots(1, 2)\n",
+    "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[0].legend()\n",
+    "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+    "\n",
+    "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+    "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+    "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[1].set_xlabel(\"Max pixel value\")\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NhRpPEjdARAw"
+   },
+   "source": [
+    "## Data Processing\n",
+    "\n",
+    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+    "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+    "\n",
+    "For this, let's try bringing all the pixels in the image between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wp_k5XTiARAw"
+   },
+   "outputs": [],
+   "source": [
+    "transforms = torchvision.transforms.Compose([\n",
+    "    torchvision.transforms.RandomResizedCrop(32, 164), # Resize the images to 64 x 64 pixels\n",
+    "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+    "])\n",
+    "\n",
+    "# We can apply other transforms, in a process called \"data augmentation\"\n",
+    "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+    "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6gXn05XNARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Look at some processed samples!\n",
+    "\n",
+    "n_samples = 9\n",
+    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+    "for image, label in samples:\n",
+    "    image = transforms(image)\n",
+    "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+    "    plt.xlabel(label_map[label.item()])\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HJEKKWHpARAx"
+   },
+   "source": [
+    "## Make the binary classification model\n",
+    "\n",
+    "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+    "\n",
+    "In this case, what we want:\n",
+    "* Take the input images from the data generator\n",
+    "* Apply two convolutional blocks to the input image\n",
+    "* Decode the second convolution block's output to a probability of the image being a given class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yb6L7SDoARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a simple convolusional model\n",
+    "\n",
+    "class SimpleCNN(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "      super().__init__()\n",
+    "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+    "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "\n",
+    "      # Pooling layer\n",
+    "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+    "      # 64 channels * 8x8 = 4096 input features\n",
+    "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+    "      self.fc2 = torch.nn.Linear(128, 1)\n",
+    "\n",
+    "      # Dropout\n",
+    "      self.dropout = torch.nn.Dropout(0.3)\n",
+    "\n",
+    "      # Activation\n",
+    "      self.relu = torch.nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+    "      if x.dim() == 3:\n",
+    "          \"???\"\n",
+    "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+    "      x = self.pool(self.relu(self.conv1(x)))\n",
+    "\n",
+    "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+    "      x = self.pool(self.relu(self.conv2(x)))\n",
+    "\n",
+    "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+    "\n",
+    "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+    "      x = x.view(x.size(0), -1)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      x = self.relu(self.fc1(x))\n",
+    "      x = self.dropout(x)\n",
+    "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+    "\n",
+    "      return torch.softmax(x.squeeze()) # Output of (batch_size)\n",
+    "\n",
+    "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NqOS_59-ARAy"
+   },
+   "source": [
+    "## Training process\n",
+    "\n",
+    "Based on the previous lessons, we know we need a few things to train a model\n",
+    "\n",
+    "### Loss and Optimizer\n",
+    "\n",
+    "\n",
+    "### Training and Validation data loops\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "CPJDwFxSARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize the model once\n",
+    "model = SimpleCNN()\n",
+    "\n",
+    "# Random choices of optimizer and loss functions\n",
+    "# These are pretty standard for classification\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
+    "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6XyF3QGjARAy"
+   },
+   "source": [
+    "# Train the model\n",
+    "\n",
+    "We have all the pieces in place:\n",
+    "- [x] Model\n",
+    "- [x] Train Data\n",
+    "- [x] Validation Data\n",
+    "- [x] Loss Function\n",
+    "- [x] Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "adEJ4vhuARAy"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def train_epoch(model, dataloader, optimizer, criterion):\n",
+    "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Training...\")\n",
+    "    for images, labels in iterer:\n",
+    "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+    "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+    "      # Update the model parameters using the computed gradients\n",
+    "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "      iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "\n",
+    "def val_epoch(model, dataloader, criterion):\n",
+    "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Validating...\")\n",
+    "    # Disable gradient computation for validation\n",
+    "    for images, labels in iterer:\n",
+    "        outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "        loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "        batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "        iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "# One epoch should take around 15 seconds\n",
+    "# The number of epochs is depednent on the complexity and size of your data\n",
+    "n_epochs = 2\n",
+    "loss_history = {\"train\": [], \"val\": []}\n",
+    "for epoch in range(n_epochs):\n",
+    "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+    "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+    "\n",
+    "    loss_history[\"train\"].append(train_loss)\n",
+    "    loss_history[\"val\"].append(val_loss)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3QCcxf0dARAy"
+   },
+   "source": [
+    "## Model Evaluation\n",
+    "\n",
+    "There are some steps we can take to see how well a model trained.\n",
+    "\n",
+    "### Loss Plots\n",
+    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pfDIpqHGARAy"
+   },
+   "outputs": [],
+   "source": [
+    "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+    "# Eval.plot_history is a simple function\n",
+    "# plots the loss as a function of epoch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V_9R4WYqARAy"
+   },
+   "source": [
+    "## Classification Accuracy Plots\n",
+    "\n",
+    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+    "\n",
+    "### ROC\n",
+    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+    "It shows how likely a model is to correctly predict something.\n",
+    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+    "\n",
+    "\n",
+    "### Confusion Matrix\n",
+    "\n",
+    "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+    "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+    "It plots the rate of predicted values for a given class versus the true values.\n",
+    "\n",
+    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iP_xgNcMARAy"
+   },
+   "outputs": [],
+   "source": [
+    "test_generator = SkyGenerator(n_samples=1280, dataset=TestDataset, shuffle=True).get_dataloader()\n",
+    "\n",
+    "def make_prediction(model, test_generator):\n",
+    "    predictions = []\n",
+    "    labels = []\n",
+    "    for image, label in test_generator:\n",
+    "        predictions += model(transforms(image))\n",
+    "        labels += label\n",
+    "    prediction_classes = torch.where(torch.tensor(predictions)<0.5, 0, 1)\n",
+    "    labels = torch.tensor(labels)\n",
+    "    return prediction_classes, labels\n",
+    "\n",
+    "def test_quality(prediction, labels):\n",
+    "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+    "    return accuracy.numpy()\n",
+    "\n",
+    "prediction, labels = make_prediction(model, test_generator)\n",
+    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5f5Q78_IARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# And now run them on your own data!\n",
+    "Eval.ROC_curve(prediction, labels)\n",
+    "Eval.confusion_matrix(prediction, labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G671xYOV7yfd"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/Challenge/challenges/challenge04.ipynb b/Challenge/challenges/challenge04.ipynb
new file mode 100644
index 0000000..01305e6
--- /dev/null
+++ b/Challenge/challenges/challenge04.ipynb
@@ -0,0 +1,604 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jToNcYCsARAt"
+   },
+   "source": [
+    "## Model Training Challenge!\n",
+    "\n",
+    "In this notebook, there are a whole host of weird errors.\n",
+    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+    "Do your best to sniff out the mistakes in both code and training procedure!\n",
+    "\n",
+    "Your mission, should you choose to accept it, is:\n",
+    "* Work together in groups of 4 to complete this notebook\n",
+    "* Figure out all the coding mistakes and make a notebook that runs\n",
+    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RX8h5B-GARAt"
+   },
+   "source": [
+    "This line below installs a non-standard data generation package.\n",
+    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+    "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VPUeGpTrARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install deepbench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xatOAXZ6ARAu"
+   },
+   "source": [
+    "`curl` is a package for downloading files off the internet.\n",
+    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+    "This file is also in the github repo, you can look at it there if you want.\n",
+    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Kjo3hTS_ARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MKc8rBCmARAu"
+   },
+   "outputs": [],
+   "source": [
+    "# Now we'll import the different classes from this new file\n",
+    "# Import the dataloader and dataset classes\n",
+    "from challenge_utilities import SkaiDataset04 as SkyDataset # Dataset object itself\n",
+    "# A subclass of torch.utils.data.Dataset\n",
+    "from challenge_utilities import SkyGenerator, TestDataset # Generic dataloader object, same for all challenges\n",
+    "from challenge_utilities import Eval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2IXmuM_EARAv"
+   },
+   "outputs": [],
+   "source": [
+    "# Standard packages\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torchvision\n",
+    "from torchsummary import summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W9XZQhfDARAv"
+   },
+   "source": [
+    "#### Package documentation\n",
+    "\n",
+    "If you get stuck for syntax or anything - these are the packages used.\n",
+    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+    "\n",
+    "[MatPlotLib](https://matplotlib.org/)\n",
+    "\n",
+    "[Pytorch](https://docs.pytorch.org/docs/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m5EFoTAgARAv"
+   },
+   "source": [
+    "# Exploratory Data Analysis\n",
+    "\n",
+    "Understanding your data is a critical part of any AI/ML project.\n",
+    "Make sure you look at your data and understand the differences between each class.\n",
+    "\n",
+    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+    "You can use this to label your plots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "66Gal0ukARAv"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "label_map = {\n",
+    "    0: \"Star\",\n",
+    "    1: \"Galaxy\"\n",
+    "}\n",
+    "\n",
+    "def plot_samples(generator, n_columns=3, n_rows=6, label_map:dict|None=None):\n",
+    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+    "    plt.tight_layout()\n",
+    "    plt.setp(subplots, xticks=[], yticks=[])\n",
+    "\n",
+    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+    "        image, label = generator.get(sample_index)\n",
+    "        subplot.imshow(image)\n",
+    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+    "\n",
+    "        string_label = \"??????\"\n",
+    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+    "\n",
+    "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+    "plot_samples(samples, label_map=label_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VTG-xMYWARAw"
+   },
+   "source": [
+    "# Look at the input data\n",
+    "\n",
+    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6FJGVsZgARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# These two generators produce the data we'll train with\n",
+    "\n",
+    "n_train_samples = 20\n",
+    "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+    "\n",
+    "n_val_samples = 1280\n",
+    "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KM_sOu9sARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+    "\n",
+    "fig, ax = plt.subplots(1,2)\n",
+    "ax[0].hist(train_generator.dataset.labels)\n",
+    "ax[0].set_title(\"Train labels\")\n",
+    "ax[1].hist(val_generator.dataset.labels)\n",
+    "ax[1].set_title(\"Val labels\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TwAsJhDMARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# We can also look at different attributes of the images\n",
+    "# Here, let's look at max values and mean values\n",
+    "\n",
+    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+    "\n",
+    "# Normally we would also have some metadata to work with, but here we only have images\n",
+    "\n",
+    "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "figure, subplots = plt.subplots(1, 2)\n",
+    "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[0].legend()\n",
+    "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+    "\n",
+    "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+    "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+    "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[1].set_xlabel(\"Max pixel value\")\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NhRpPEjdARAw"
+   },
+   "source": [
+    "## Data Processing\n",
+    "\n",
+    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+    "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+    "\n",
+    "For this, let's try bringing all the pixels in the image between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wp_k5XTiARAw"
+   },
+   "outputs": [],
+   "source": [
+    "transforms = torchvision.transforms.Compose([\n",
+    "    torchvision.transforms.RandomResizedCrop(32, 164), # Resize the images to 64 x 64 pixels\n",
+    "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+    "])\n",
+    "\n",
+    "# We can apply other transforms, in a process called \"data augmentation\"\n",
+    "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+    "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6gXn05XNARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Look at some processed samples!\n",
+    "\n",
+    "n_samples = 9\n",
+    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+    "for image, label in samples:\n",
+    "    image = transforms(image)\n",
+    "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+    "    plt.xlabel(label_map[label.item()])\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HJEKKWHpARAx"
+   },
+   "source": [
+    "## Make the binary classification model\n",
+    "\n",
+    "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+    "\n",
+    "In this case, what we want:\n",
+    "* Take the input images from the data generator\n",
+    "* Apply two convolutional blocks to the input image\n",
+    "* Decode the second convolution block's output to a probability of the image being a given class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yb6L7SDoARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a simple convolusional model\n",
+    "\n",
+    "class SimpleCNN(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "      super().__init__()\n",
+    "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+    "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "\n",
+    "      # Pooling layer\n",
+    "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+    "      # 64 channels * 8x8 = 4096 input features\n",
+    "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+    "      self.fc2 = torch.nn.Linear(128, 1)\n",
+    "\n",
+    "      # Dropout\n",
+    "      self.dropout = torch.nn.Dropout(0.3)\n",
+    "\n",
+    "      # Activation\n",
+    "      self.relu = torch.nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+    "      if x.dim() == 3:\n",
+    "          \"???\"\n",
+    "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+    "      x = self.pool(self.relu(self.conv1(x)))\n",
+    "\n",
+    "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+    "      x = self.pool(self.relu(self.conv2(x)))\n",
+    "\n",
+    "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+    "\n",
+    "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+    "      x = x.view(x.size(0), -1)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      x = self.relu(self.fc1(x))\n",
+    "      x = self.dropout(x)\n",
+    "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+    "\n",
+    "      return torch.softmax(x.squeeze()) # Output of (batch_size)\n",
+    "\n",
+    "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NqOS_59-ARAy"
+   },
+   "source": [
+    "## Training process\n",
+    "\n",
+    "Based on the previous lessons, we know we need a few things to train a model\n",
+    "\n",
+    "### Loss and Optimizer\n",
+    "\n",
+    "\n",
+    "### Training and Validation data loops\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "CPJDwFxSARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize the model once\n",
+    "model = SimpleCNN()\n",
+    "\n",
+    "# Random choices of optimizer and loss functions\n",
+    "# These are pretty standard for classification\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
+    "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6XyF3QGjARAy"
+   },
+   "source": [
+    "# Train the model\n",
+    "\n",
+    "We have all the pieces in place:\n",
+    "- [x] Model\n",
+    "- [x] Train Data\n",
+    "- [x] Validation Data\n",
+    "- [x] Loss Function\n",
+    "- [x] Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "adEJ4vhuARAy"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def train_epoch(model, dataloader, optimizer, criterion):\n",
+    "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Training...\")\n",
+    "    for images, labels in iterer:\n",
+    "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+    "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+    "      # Update the model parameters using the computed gradients\n",
+    "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "      iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "\n",
+    "def val_epoch(model, dataloader, criterion):\n",
+    "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Validating...\")\n",
+    "    # Disable gradient computation for validation\n",
+    "    for images, labels in iterer:\n",
+    "        outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "        loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "        batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "        iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "# One epoch should take around 15 seconds\n",
+    "# The number of epochs is depednent on the complexity and size of your data\n",
+    "n_epochs = 2\n",
+    "loss_history = {\"train\": [], \"val\": []}\n",
+    "for epoch in range(n_epochs):\n",
+    "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+    "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+    "\n",
+    "    loss_history[\"train\"].append(train_loss)\n",
+    "    loss_history[\"val\"].append(val_loss)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3QCcxf0dARAy"
+   },
+   "source": [
+    "## Model Evaluation\n",
+    "\n",
+    "There are some steps we can take to see how well a model trained.\n",
+    "\n",
+    "### Loss Plots\n",
+    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pfDIpqHGARAy"
+   },
+   "outputs": [],
+   "source": [
+    "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+    "# Eval.plot_history is a simple function\n",
+    "# plots the loss as a function of epoch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V_9R4WYqARAy"
+   },
+   "source": [
+    "## Classification Accuracy Plots\n",
+    "\n",
+    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+    "\n",
+    "### ROC\n",
+    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+    "It shows how likely a model is to correctly predict something.\n",
+    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+    "\n",
+    "\n",
+    "### Confusion Matrix\n",
+    "\n",
+    "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+    "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+    "It plots the rate of predicted values for a given class versus the true values.\n",
+    "\n",
+    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iP_xgNcMARAy"
+   },
+   "outputs": [],
+   "source": [
+    "test_generator = SkyGenerator(n_samples=1280, dataset=TestDataset, shuffle=True).get_dataloader()\n",
+    "\n",
+    "def make_prediction(model, test_generator):\n",
+    "    predictions = []\n",
+    "    labels = []\n",
+    "    for image, label in test_generator:\n",
+    "        predictions += model(transforms(image))\n",
+    "        labels += label\n",
+    "    prediction_classes = torch.where(torch.tensor(predictions)<0.5, 0, 1)\n",
+    "    labels = torch.tensor(labels)\n",
+    "    return prediction_classes, labels\n",
+    "\n",
+    "def test_quality(prediction, labels):\n",
+    "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+    "    return accuracy.numpy()\n",
+    "\n",
+    "prediction, labels = make_prediction(model, test_generator)\n",
+    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5f5Q78_IARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# And now run them on your own data!\n",
+    "Eval.ROC_curve(prediction, labels)\n",
+    "Eval.confusion_matrix(prediction, labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G671xYOV7yfd"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/Challenge/challenges/challenge05.ipynb b/Challenge/challenges/challenge05.ipynb
new file mode 100644
index 0000000..32e8370
--- /dev/null
+++ b/Challenge/challenges/challenge05.ipynb
@@ -0,0 +1,604 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jToNcYCsARAt"
+   },
+   "source": [
+    "## Model Training Challenge!\n",
+    "\n",
+    "In this notebook, there are a whole host of weird errors.\n",
+    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking.\n",
+    "Do your best to sniff out the mistakes in both code and training procedure!\n",
+    "\n",
+    "Your mission, should you choose to accept it, is:\n",
+    "* Work together in groups of 4 to complete this notebook\n",
+    "* Figure out all the coding mistakes and make a notebook that runs\n",
+    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
+    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RX8h5B-GARAt"
+   },
+   "source": [
+    "This line below installs a non-standard data generation package.\n",
+    "It is designed to make images for benchmarking computer vision problems, and is the back bone of your generator.\n",
+    "Unfortunately, it's not included with colab (which makes sense....), so we have to install it.\n",
+    "The `!` point here means \"Execute this line like it's a line in a bash prompt\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VPUeGpTrARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install deepbench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xatOAXZ6ARAu"
+   },
+   "source": [
+    "`curl` is a package for downloading files off the internet.\n",
+    "This below line just downloads a file form the repo into this colab instance, and names it \"challenge_utilities.py\".\n",
+    "This file is also in the github repo, you can look at it there if you want.\n",
+    "It contains the data generator for each for your challenges, and the utilities for plotting and evaluating results.\n",
+    "(It won't contain any problems for you to solve, it's just there to keep this notebook from getting cluttered.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Kjo3hTS_ARAu"
+   },
+   "outputs": [],
+   "source": [
+    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials/refs/heads/main/Challenge/challenge_utilities.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MKc8rBCmARAu"
+   },
+   "outputs": [],
+   "source": [
+    "# Now we'll import the different classes from this new file\n",
+    "# Import the dataloader and dataset classes\n",
+    "from challenge_utilities import SkaiDataset01 as SkyDataset # Dataset object itself\n",
+    "# A subclass of torch.utils.data.Dataset\n",
+    "from challenge_utilities import SkyGenerator, TestDataset # Generic dataloader object, same for all challenges\n",
+    "from challenge_utilities import Eval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2IXmuM_EARAv"
+   },
+   "outputs": [],
+   "source": [
+    "# Standard packages\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torchvision\n",
+    "from torchsummary import summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W9XZQhfDARAv"
+   },
+   "source": [
+    "#### Package documentation\n",
+    "\n",
+    "If you get stuck for syntax or anything - these are the packages used.\n",
+    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names.\n",
+    "\n",
+    "[MatPlotLib](https://matplotlib.org/)\n",
+    "\n",
+    "[Pytorch](https://docs.pytorch.org/docs/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m5EFoTAgARAv"
+   },
+   "source": [
+    "# Exploratory Data Analysis\n",
+    "\n",
+    "Understanding your data is a critical part of any AI/ML project.\n",
+    "Make sure you look at your data and understand the differences between each class.\n",
+    "\n",
+    "Something to note, which you would only know if you gathered the data yourself, is that the binary \"0\" and \"1\" labels correspond to \"stars\" and \"galaxies\".\n",
+    "You can use this to label your plots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "66Gal0ukARAv"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "label_map = {\n",
+    "    0: \"Star\",\n",
+    "    1: \"Galaxy\"\n",
+    "}\n",
+    "\n",
+    "def plot_samples(generator, n_columns=3, n_rows=6, label_map:dict|None=None):\n",
+    "    _, subplots = plt.subplots(n_columns, n_rows) # Make 9 plots in a 3 x 3 grid\n",
+    "    plt.tight_layout()\n",
+    "    plt.setp(subplots, xticks=[], yticks=[])\n",
+    "\n",
+    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()):\n",
+    "        image, label = generator.get(sample_index)\n",
+    "        subplot.imshow(image)\n",
+    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels).\n",
+    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
+    "\n",
+    "        string_label = \"??????\"\n",
+    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
+    "\n",
+    "samples = SkyDataset(n_samples=9, seed=42) # Can just get a few samples\n",
+    "plot_samples(samples, label_map=label_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VTG-xMYWARAw"
+   },
+   "source": [
+    "# Look at the input data\n",
+    "\n",
+    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6FJGVsZgARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# These two generators produce the data we'll train with\n",
+    "\n",
+    "n_train_samples = 20\n",
+    "train_generator = SkyGenerator(n_samples=n_train_samples,  dataset=SkyDataset, shuffle=True)\n",
+    "\n",
+    "n_val_samples = 1280\n",
+    "val_generator = SkyGenerator(n_samples=n_val_samples, dataset=SkyDataset, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KM_sOu9sARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# Each dataset object has a \"labels\" and \"images\" attribute, which we can use to check out the data range\n",
+    "\n",
+    "fig, ax = plt.subplots(1,2)\n",
+    "ax[0].hist(train_generator.dataset.labels)\n",
+    "ax[0].set_title(\"Train labels\")\n",
+    "ax[1].hist(val_generator.dataset.labels)\n",
+    "ax[1].set_title(\"Val labels\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TwAsJhDMARAw"
+   },
+   "outputs": [],
+   "source": [
+    "# We can also look at different attributes of the images\n",
+    "# Here, let's look at max values and mean values\n",
+    "\n",
+    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated\n",
+    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
+    "\n",
+    "# Normally we would also have some metadata to work with, but here we only have images\n",
+    "\n",
+    "train_means = train_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "val_means = val_generator.dataset.images.mean(axis=(1, 0))\n",
+    "\n",
+    "figure, subplots = plt.subplots(1, 2)\n",
+    "subplots[0].hist(train_means, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[0].hist(val_means,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[0].legend()\n",
+    "subplots[0].set_xlabel(\"Mean pixel value\")\n",
+    "\n",
+    "train_maxes = train_generator.dataset.images.max(axis=(1, 0))\n",
+    "val_maxes = val_generator.dataset.images.max(axis=(1, 0))\n",
+    "subplots[1].hist(train_maxes, color=\"orange\", edgecolor=\"black\", label=\"Train\", alpha=0.4)\n",
+    "subplots[1].hist(val_maxes,  color=\"blue\", edgecolor=\"black\", label=\"Validation\", alpha=0.4)\n",
+    "subplots[1].set_xlabel(\"Max pixel value\")\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NhRpPEjdARAw"
+   },
+   "source": [
+    "## Data Processing\n",
+    "\n",
+    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
+    "There are near infinite ways to pre-process, especially in the computer vision space.\n",
+    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways.\n",
+    "\n",
+    "For this, let's try bringing all the pixels in the image between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wp_k5XTiARAw"
+   },
+   "outputs": [],
+   "source": [
+    "transforms = torchvision.transforms.Compose([\n",
+    "    torchvision.transforms.RandomResizedCrop(32, 164), # Resize the images to 64 x 64 pixels\n",
+    "    torchvision.transforms.Normalize(0.5, 0.5) # Normalize the pixel values to be between 0 and 1\n",
+    "])\n",
+    "\n",
+    "# We can apply other transforms, in a process called \"data augmentation\"\n",
+    "# It helps make the model less likely to overfit by giving it different versions of the same data during the training process\n",
+    "# All transforms can be seen here - https://docs.pytorch.org/vision/0.26/transforms.html#v2-api-reference-recommended"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6gXn05XNARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Look at some processed samples!\n",
+    "\n",
+    "n_samples = 9\n",
+    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, dataset=SkyDataset).get_dataloader()\n",
+    "for image, label in samples:\n",
+    "    image = transforms(image)\n",
+    "    plt.imshow(image[0][0]) # The image size is given as (batch, im channels, im_size, im_size)\n",
+    "    plt.xlabel(label_map[label.item()])\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HJEKKWHpARAx"
+   },
+   "source": [
+    "## Make the binary classification model\n",
+    "\n",
+    "This function, when called, produces a keras Model instance that you can train to predict a class of an input.\n",
+    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1.\n",
+    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out.\n",
+    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it.\n",
+    "\n",
+    "In this case, what we want:\n",
+    "* Take the input images from the data generator\n",
+    "* Apply two convolutional blocks to the input image\n",
+    "* Decode the second convolution block's output to a probability of the image being a given class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yb6L7SDoARAx"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a simple convolusional model\n",
+    "\n",
+    "class SimpleCNN(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "      super().__init__()\n",
+    "      self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
+    "      self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "      self.conv3 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "\n",
+    "      # Pooling layer\n",
+    "      self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      # After 3 pooling layers: 64 -> 32 -> 16 -> 8, so feature map is 8x8\n",
+    "      # 64 channels * 8x8 = 4096 input features\n",
+    "      self.fc1 = torch.nn.Linear(64 * 8 * 8, 128)\n",
+    "      self.fc2 = torch.nn.Linear(128, 1)\n",
+    "\n",
+    "      # Dropout\n",
+    "      self.dropout = torch.nn.Dropout(0.3)\n",
+    "\n",
+    "      # Activation\n",
+    "      self.relu = torch.nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "      # Input: (batch_size, 64, 64) - need to add channel dimension\n",
+    "      if x.dim() == 3:\n",
+    "          \"???\"\n",
+    "      # Conv block 1: (batch_size, 1, 64, 64) -> (batch_size, 16, 32, 32)\n",
+    "      x = self.pool(self.relu(self.conv1(x)))\n",
+    "\n",
+    "      # Conv block 2: (batch_size, 16, 32, 32) -> (batch_size, 32, 16, 16)\n",
+    "      x = self.pool(self.relu(self.conv2(x)))\n",
+    "\n",
+    "      # Conv block 3: (batch_size, 32, 16, 16) -> (batch_size, 64, 8, 8)\n",
+    "\n",
+    "      # Flatten: (batch_size, 64*8*8) = (batch_size, 4096)\n",
+    "      x = x.view(x.size(0), -1)\n",
+    "\n",
+    "      # Fully connected layers\n",
+    "      x = self.relu(self.fc1(x))\n",
+    "      x = self.dropout(x)\n",
+    "      x = self.fc2(x)  # Output: (batch_size, 1)\n",
+    "\n",
+    "      return torch.softmax(x.squeeze()) # Output of (batch_size)\n",
+    "\n",
+    "print(summary(SimpleCNN(), input_size=(1, 64, 64)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NqOS_59-ARAy"
+   },
+   "source": [
+    "## Training process\n",
+    "\n",
+    "Based on the previous lessons, we know we need a few things to train a model\n",
+    "\n",
+    "### Loss and Optimizer\n",
+    "\n",
+    "\n",
+    "### Training and Validation data loops\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "CPJDwFxSARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize the model once\n",
+    "model = SimpleCNN()\n",
+    "\n",
+    "# Random choices of optimizer and loss functions\n",
+    "# These are pretty standard for classification\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
+    "criterion = torch.nn.BCELoss()  # BCE = Binary Cross Entropy (for 2 classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6XyF3QGjARAy"
+   },
+   "source": [
+    "# Train the model\n",
+    "\n",
+    "We have all the pieces in place:\n",
+    "- [x] Model\n",
+    "- [x] Train Data\n",
+    "- [x] Validation Data\n",
+    "- [x] Loss Function\n",
+    "- [x] Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "adEJ4vhuARAy"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "def train_epoch(model, dataloader, optimizer, criterion):\n",
+    "    \"\"\"Trains the model for a single epoch (one loop through the entire training dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Training...\")\n",
+    "    for images, labels in iterer:\n",
+    "      optimizer.zero_grad() # Clear the gradients from the previous step\n",
+    "      outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "      loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "      loss.backward() # Backward pass: compute the gradients of the loss with respect to the model parameters\n",
+    "      # Update the model parameters using the computed gradients\n",
+    "      batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "      iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "\n",
+    "def val_epoch(model, dataloader, criterion):\n",
+    "    \"\"\"Evaluates the model on the validation set for a single epoch (one loop through the entire validation dataset)\"\"\"\n",
+    "    batch_loss = torch.tensor(0.0) # Initialize the batch loss to 0\n",
+    "    n_batches = len(dataloader)\n",
+    "    iterer = tqdm(dataloader, desc=\"Validating...\")\n",
+    "    # Disable gradient computation for validation\n",
+    "    for images, labels in iterer:\n",
+    "        outputs = model(transforms(images)) # Forward pass: compute the model output for the current batch of images\n",
+    "        loss = criterion(outputs.to(float), labels.to(float)) # Compute the loss between the model output and the true labels\n",
+    "        batch_loss += loss.item() # Accumulate the loss for this batch\n",
+    "        iterer.set_postfix(loss=loss.item())\n",
+    "    return model, batch_loss.item() / n_batches # Return the average loss for this epoch\n",
+    "\n",
+    "# One epoch should take around 15 seconds\n",
+    "# The number of epochs is depednent on the complexity and size of your data\n",
+    "n_epochs = 2\n",
+    "loss_history = {\"train\": [], \"val\": []}\n",
+    "for epoch in range(n_epochs):\n",
+    "    model, train_loss = train_epoch(model, train_generator.get_dataloader(), optimizer, criterion)\n",
+    "    model, val_loss = val_epoch(model, val_generator.get_dataloader(), criterion)\n",
+    "\n",
+    "    loss_history[\"train\"].append(train_loss)\n",
+    "    loss_history[\"val\"].append(val_loss)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3QCcxf0dARAy"
+   },
+   "source": [
+    "## Model Evaluation\n",
+    "\n",
+    "There are some steps we can take to see how well a model trained.\n",
+    "\n",
+    "### Loss Plots\n",
+    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training.\n",
+    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem.\n",
+    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pfDIpqHGARAy"
+   },
+   "outputs": [],
+   "source": [
+    "Eval.plot_loss_history(loss_history['train'], loss_history['val'])\n",
+    "# Eval.plot_history is a simple function\n",
+    "# plots the loss as a function of epoch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V_9R4WYqARAy"
+   },
+   "source": [
+    "## Classification Accuracy Plots\n",
+    "\n",
+    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training.\n",
+    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it.\n",
+    "\n",
+    "### ROC\n",
+    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate.\n",
+    "It shows how likely a model is to correctly predict something.\n",
+    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves.\n",
+    "\n",
+    "\n",
+    "### Confusion Matrix\n",
+    "\n",
+    "Confusion matrices are a great tool for seeing how well each class does against each other.\n",
+    "It gets it name from its ability to tell if a model is \"confusing\" two different classes.\n",
+    "It plots the rate of predicted values for a given class versus the true values.\n",
+    "\n",
+    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iP_xgNcMARAy"
+   },
+   "outputs": [],
+   "source": [
+    "test_generator = SkyGenerator(n_samples=1280, dataset=TestDataset, shuffle=True).get_dataloader()\n",
+    "\n",
+    "def make_prediction(model, test_generator):\n",
+    "    predictions = []\n",
+    "    labels = []\n",
+    "    for image, label in test_generator:\n",
+    "        predictions += model(transforms(image))\n",
+    "        labels += label\n",
+    "    prediction_classes = torch.where(torch.tensor(predictions)<0.5, 0, 1)\n",
+    "    labels = torch.tensor(labels)\n",
+    "    return prediction_classes, labels\n",
+    "\n",
+    "def test_quality(prediction, labels):\n",
+    "    accuracy = torch.mean((prediction == labels).float()) # Compute the accuracy by comparing the predicted classes to the true labels\n",
+    "    return accuracy.numpy()\n",
+    "\n",
+    "prediction, labels = make_prediction(model, test_generator)\n",
+    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5f5Q78_IARAy"
+   },
+   "outputs": [],
+   "source": [
+    "# And now run them on your own data!\n",
+    "Eval.ROC_curve(prediction, labels)\n",
+    "Eval.confusion_matrix(prediction, labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G671xYOV7yfd"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/Challenge/challenges/challenge_01.ipynb b/Challenge/challenges/challenge_01.ipynb
deleted file mode 100644
index 33b9d73..0000000
--- a/Challenge/challenges/challenge_01.ipynb
+++ /dev/null
@@ -1,493 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Training Challenge! \n",
-    "\n",
-    "In this notebook, there are a whole host of weird errors. \n",
-    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking. \n",
-    "Do your best to sniff out the mistakes in both code and training procedure! \n",
-    "\n",
-    "Your mission, should you choose to accept it, is: \n",
-    "* Work together in groups of 4 to complete this notebook\n",
-    "* Figure out all the coding mistakes and make a notebook that runs\n",
-    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them.\n",
-    "\n",
-    "### Rules \n",
-    "* If you cannot correct the problem, identify it and write a quick paragraph about what you would do\n",
-    "* You are allowed to use any resource you can find; other groups, TA's, a random scientist walking by, and most importantly, the internet. The use of generative AI is highly discouraged - not because it's cheating, but because it can send you down rabbit holes that are hard to find your way out of. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installing the data generation package \n",
-    "! pip install deepbench"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials_2024/main/Challenge/challenge_utilities.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we'll import the different classes from this new file \n",
-    "from challenge_utilities import SkyGenerator01 as SkyGenerator # `as` renames the imported package name\n",
-    "from challenge_utilities import Eval"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you have an issue with this, re-downloading the file may fix it.\n",
-    "If this still doesn't help, [directly pull the file from the github link](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/40758642b5570a3fe53dc49da237a19f5e748a78/07_Challenge/challenge_utilities.py)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Standard packages \n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from tensorflow.keras.layers import Input, Dropout, Conv1D, Dense, AvgPool1D, Flatten\n",
-    "from tensorflow.keras.models import Model\n",
-    "\n",
-    "import tensorflow as tf \n",
-    "from sklearn.preprocessing import MinMaxScaler"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Package documentation \n",
-    "\n",
-    "If you get stuck for syntax or anything - these are the packages used. \n",
-    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names. \n",
-    "\n",
-    "[Numpy]()\n",
-    "\n",
-    "[MatPlotLib]() \n",
-    "\n",
-    "[Tensorflow/tf/Keras]()\n",
-    "\n",
-    "[Sci-kit Learn]()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "label_map = {\n",
-    "    0: \"Star\", \n",
-    "    1: \"Galaxy\"\n",
-    "}\n",
-    "\n",
-    "\n",
-    "def plot_samples(generator, n_columns=3, n_rows=3, label_map=None): \n",
-    "    _, subplots = plt.subplots(n_columns, 1) # Make 9 plots in a 3 x 3 grid \n",
-    "    plt.tight_layout()\n",
-    "    plt.setp(subplots, xticks=[], yticks=[])\n",
-    "\n",
-    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()): \n",
-    "        image, label = generator[sample_index]\n",
-    "        subplot.imshow(image.squeeze()) \n",
-    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels). \n",
-    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-    "        \n",
-    "        string_label = \"??\" \n",
-    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-    "\n",
-    "samples = SkyGenerator(n_samples=9, batch_size=1) # Can just get a few samples\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Look at the input data \n",
-    "\n",
-    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_train_samples = 1280\n",
-    "train_generator = SkyGenerator(n_samples=n_train_samples, shuffle=True)\n",
-    "\n",
-    "n_val_samples = 1280\n",
-    "val_generator = SkyGenerator(n_samples=n_val_samples, train=False, shuffle=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can look at the distribution of labels by grabbing them from the generator \n",
-    "    # TF.Sequence generators supply data as a tuple \n",
-    "    # of (x,y) (or (features, labels)) \n",
-    "    # - so using index 1 we can get the labels\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][1] for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0] for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots.hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.supxlabel(\"Label Distributions\")\n",
-    "figure.supylabel(\"Label Frequency\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can also look at different attributes of the images \n",
-    "# Here, let's look at max values and mean values\n",
-    "\n",
-    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated \n",
-    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().mean() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].mean() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Mean value of pixels in a single image\")\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().max() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].ravel().max() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Max value of pixels in a single image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Processing\n",
-    "\n",
-    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-    "There are near infinite ways to pre-process, especially in the computer vision space. \n",
-    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways. \n",
-    "\n",
-    "For this, let's try bringing all the pixels in the image between 0 and 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "scaler = MinMaxScaler((0, 1))\n",
-    "\n",
-    "fit_data = np.concatenate([train_generator[i][0] for i in range(5)], axis=0) \n",
-    "# This is 5 batches of data, being used to find the approximate min and max of the data\n",
-    "# Because our data is synthetic, we don't need to worry about big outliers\n",
-    "\n",
-    "# Unfortunately, minmaxscaler only handles 1d of data, so we need to do a little pre-and-post processing on the input \n",
-    "# combining the last two dimensions together, making the 2d of the image 1d instead. \n",
-    "fit_data = fit_data.reshape((fit_data.shape[0], fit_data.shape[1]*fit_data.shape[2]) ) \n",
-    "scaler_fit = scaler.fit(fit_data)\n",
-    "\n",
-    "def processor(image): \n",
-    "    # This function will take a single image and return the scaled version \n",
-    "    image_flat = image.ravel() \n",
-    "    image_scaled = scaler_fit.transform(image_flat.reshape(1, -1))\n",
-    "    # Magically reshape it back into 2d \n",
-    "    image_scaled_reshaped = image_scaled.reshape(image.shape)\n",
-    "    return image_scaled_reshaped"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Look at the samples again! \n",
-    "\n",
-    "n_samples = 9\n",
-    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, pre_processing=processor)\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Make the binary classification model \n",
-    "\n",
-    "This function, when called, produces a keras Model instance that you can train to predict a class of an input. \n",
-    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1. \n",
-    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out. \n",
-    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it. \n",
-    "\n",
-    "In this case, what we want: \n",
-    "* Take the input images from the data generator \n",
-    "* Apply two convolutional blocks to the input image \n",
-    "* Decode the second convolution block's output to a probability of the image being a given class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_model(): \n",
-    "    \"\"\"\n",
-    "    Make a network that can perform binary classification\n",
-    "\n",
-    "    Returns:\n",
-    "        model (keras.Model): classifier model that will \n",
-    "    \"\"\"\n",
-    "    in_layer = Input((2, 2))\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(input_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Dense(20, activation='relu')\n",
-    "\n",
-    "    x = Dropout(0.3)(x)\n",
-    "    output = Dense(10, activation='softmax')(x)\n",
-    "    model = Model(in_layer, x)\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "model = make_model()\n",
-    "loss = tf.losses.BinaryCrossentropy()\n",
-    "optimizer = tf.keras.optimizers.SGD(0.0001)\n",
-    "\n",
-    "# Compile tells the keras backend what loss and optimizer to use to perform gradients on the model\n",
-    "# You cannot train a keras model without compiling it first\n",
-    "model.compile(loss=loss, optimizer=optimizer)\n",
-    "\n",
-    "# Show what layers are in the model, and their input and output shapes \n",
-    "# This can help make sure all your stuff is a correct size\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train the model \n",
-    "\n",
-    "We have all the pieces in place:\n",
-    "- [x] Model \n",
-    "- [x] Train Data \n",
-    "- [x] Validation Data \n",
-    "- [x] Loss Function \n",
-    "- [x] Optimizer \n",
-    "\n",
-    "Now lets put this together into a fit model. \n",
-    "Keras trains in place, so you don't need a new variable to hold the `fit_model` vs `model`. \n",
-    "Once you call `fit`, the model is fit, and it re-train, you need to make a new model with the `make_model()` function. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "train_generator_scaled = SkyGenerator(n_samples=1280, pre_processing=processor, batch_size=64)\n",
-    "val_generator_scaled = SkyGenerator(n_samples=12, pre_processing=None, batch_size=64)\n",
-    "\n",
-    "history = model.fit(\n",
-    "    train_generator_scaled, \n",
-    "    validation_data=train_generator_scaled, \n",
-    "    epochs=50, \n",
-    "    verbose=1\n",
-    "    ).history\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Evaluation \n",
-    "\n",
-    "There are some steps we can take to see how well a model trained. \n",
-    "\n",
-    "### Loss Plots \n",
-    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training. \n",
-    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem. \n",
-    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Eval.plot_loss_history(history) \n",
-    "# Eval.plot_history is a simple function \n",
-    "# plots the loss as a function of epoch "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classification Accuracy Plots \n",
-    "\n",
-    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training. \n",
-    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it. \n",
-    "\n",
-    "### ROC\n",
-    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate. \n",
-    "It shows how likely a model is to correctly predict something. \n",
-    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves. \n",
-    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/Roc_curve.svg/800px-Roc_curve.svg.png\" width=\"300\">\n",
-    "\n",
-    "<a href=\"https://upload.wikimedia.org/wikipedia/commons/3/36/Roc-draft-xkcd-style.svg\"></a><a href=\"//commons.wikimedia.org/wiki/File:Roc-draft-xkcd-style.svg#filelinks\" title=\"File:Roc-draft-xkcd-style.svg\">Roc-draft-xkcd-style.svg</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\" title=\"Creative Commons Attribution-Share Alike 4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=109730045\">Link</a>\n",
-    "\n",
-    "\n",
-    "### Confusion Matrix\n",
-    "\n",
-    "Confusion matrices are a great tool for seeing how well each class does against each other. \n",
-    "It gets it name from its ability to tell if a model is \"confusing\" two different classes. \n",
-    "It plots the rate of predicted values for a given class versus the true values. \n",
-    "\n",
-    "<img src=\"https://www.ibm.com/content/dam/connectedassets-adobe-cms/worldwide-content/creative-assets/s-migr/ul/g/c8/a7/binary-matrix.component.complex-narrative-xl.ts=1712087356966.png/content/adobe-cms/us/en/topics/confusion-matrix/jcr:content/root/table_of_contents/body/content_section_styled/content-section-body/complex_narrative_390941229/items/content_group/image\" width='400'>\n",
-    "\n",
-    " <a href=\"https://www.ibm.com/topics/confusion-matrix\">Link</a>\n",
-    "\n",
-    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generator = SkyGenerator(n_samples=1280, train=False, shuffle=True)\n",
-    "\n",
-    "def make_prediction(model, test_generator): \n",
-    "    predictions = trained_model.predict(test_generator)\n",
-    "    prediction_classes = np.where(predictions<0.5, 0, 1)\n",
-    "    labels = test_generator.labels\n",
-    "    return prediction_classes, labels\n",
-    "\n",
-    "def test_quality(prediction, labels): \n",
-    "    accuracy = tf.keras.metrics.BinaryAccuracy()(labels, labels)\n",
-    "    return accuracy.numpy()\n",
-    "\n",
-    "prediction, labels = make_prediction(model, test_generator)\n",
-    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now run them on your own data! \n",
-    "Eval.ROC_curve(prediction, labels)\n",
-    "Eval.confusion_matrix(labels, labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Challenge/challenges/challenge_02.ipynb b/Challenge/challenges/challenge_02.ipynb
deleted file mode 100644
index 89f3da0..0000000
--- a/Challenge/challenges/challenge_02.ipynb
+++ /dev/null
@@ -1,502 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Training Challenge! \n",
-    "\n",
-    "In this notebook, there are a whole host of weird errors. \n",
-    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking. \n",
-    "Do your best to sniff out the mistakes in both code and training procedure! \n",
-    "\n",
-    "Your mission, should you choose to accept it, is: \n",
-    "* Work together in groups of 4 to complete this notebook\n",
-    "* Figure out all the coding mistakes and make a notebook that runs\n",
-    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them.\n",
-    "\n",
-    "### Rules \n",
-    "* If you cannot correct the problem, identify it and write a quick paragraph about what you would do\n",
-    "* You are allowed to use any resource you can find; other groups, TA's, a random scientist walking by, and most importantly, the internet. The use of generative AI is highly discouraged - not because it's cheating, but because it can send you down rabbit holes that are hard to find your way out of. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installing the data generation package \n",
-    "! pip install deepbench"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials_2024/main/Challenge/challenge_utilities.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we'll import the different classes from this new file \n",
-    "from challenge_utilities import SkyGenerator02 as SkyGenerator # `as` renames the imported package name\n",
-    "from challenge_utilities import Eval"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you have an issue with this, re-downloading the file may fix it.\n",
-    "If this still doesn't help, [directly pull the file from the github link](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/40758642b5570a3fe53dc49da237a19f5e748a78/07_Challenge/challenge_utilities.py)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Standard packages \n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from tensorflow.keras.layers import Input, Dropout, Conv1D, Dense, AvgPool1D, Flatten\n",
-    "from tensorflow.keras.models import Model\n",
-    "\n",
-    "import tensorflow as tf \n",
-    "from sklearn.preprocessing import MinMaxScaler"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Package documentation \n",
-    "\n",
-    "If you get stuck for syntax or anything - these are the packages used. \n",
-    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names. \n",
-    "\n",
-    "[Numpy]()\n",
-    "\n",
-    "[MatPlotLib]() \n",
-    "\n",
-    "[Tensorflow/tf/Keras]()\n",
-    "\n",
-    "[Sci-kit Learn]()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "label_map = {\n",
-    "    0: \"Star\", \n",
-    "    1: \"Galaxy\"\n",
-    "}\n",
-    "\n",
-    "\n",
-    "def plot_samples(generator, n_columns=3, n_rows=3, label_map=None): \n",
-    "    _, subplots = plt.subplots(n_columns, 1) # Make 9 plots in a 3 x 3 grid \n",
-    "    plt.tight_layout()\n",
-    "    plt.setp(subplots, xticks=[], yticks=[])\n",
-    "\n",
-    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()): \n",
-    "        image, label = generator[sample_index]\n",
-    "        subplot.imshow(image.squeeze()) \n",
-    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels). \n",
-    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-    "        \n",
-    "        string_label = \"??\" \n",
-    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-    "\n",
-    "samples = SkyGenerator(n_samples=9, batch_size=1) # Can just get a few samples\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Look at the input data \n",
-    "\n",
-    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_train_samples = 1280\n",
-    "train_generator = SkyGenerator(n_samples=n_train_samples, shuffle=True)\n",
-    "\n",
-    "n_val_samples = 1280\n",
-    "val_generator = SkyGenerator(n_samples=n_val_samples, train=False, shuffle=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can look at the distribution of labels by grabbing them from the generator \n",
-    "    # TF.Sequence generators supply data as a tuple \n",
-    "    # of (x,y) (or (features, labels)) \n",
-    "    # - so using index 1 we can get the labels\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][1] for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0] for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots.hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.supxlabel(\"Label Distributions\")\n",
-    "figure.supylabel(\"Label Frequency\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can also look at different attributes of the images \n",
-    "# Here, let's look at max values and mean values\n",
-    "\n",
-    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated \n",
-    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().mean() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].mean() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Mean value of pixels in a single image\")\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().max() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].ravel().max() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Max value of pixels in a single image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Processing\n",
-    "\n",
-    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-    "There are near infinite ways to pre-process, especially in the computer vision space. \n",
-    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways. \n",
-    "\n",
-    "For this, let's try bringing all the pixels in the image between 0 and 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "scaler = MinMaxScaler((0, 1))\n",
-    "\n",
-    "fit_data = np.concatenate([train_generator[i][0] for i in range(5)], axis=0) \n",
-    "# This is 5 batches of data, being used to find the approximate min and max of the data\n",
-    "# Because our data is synthetic, we don't need to worry about big outliers\n",
-    "\n",
-    "# Unfortunately, minmaxscaler only handles 1d of data, so we need to do a little pre-and-post processing on the input \n",
-    "# combining the last two dimensions together, making the 2d of the image 1d instead. \n",
-    "fit_data = fit_data.reshape((fit_data.shape[0], fit_data.shape[1]*fit_data.shape[2]) ) \n",
-    "scaler_fit = scaler.fit(fit_data)\n",
-    "\n",
-    "def processor(image): \n",
-    "    # This function will take a single image and return the scaled version \n",
-    "    image_flat = image.ravel() \n",
-    "    image_scaled = scaler_fit.transform(image_flat.reshape(1, -1))\n",
-    "    # Magically reshape it back into 2d \n",
-    "    image_scaled_reshaped = image_scaled.reshape(image.shape)\n",
-    "    return image_scaled_reshaped"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Look at the samples again! \n",
-    "\n",
-    "n_samples = 9\n",
-    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, pre_processing=processor)\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Make the binary classification model \n",
-    "\n",
-    "This function, when called, produces a keras Model instance that you can train to predict a class of an input. \n",
-    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1. \n",
-    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out. \n",
-    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it. \n",
-    "\n",
-    "In this case, what we want: \n",
-    "* Take the input images from the data generator \n",
-    "* Apply two convolutional blocks to the input image \n",
-    "* Decode the second convolution block's output to a probability of the image being a given class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_model(): \n",
-    "    \"\"\"\n",
-    "    Make a network that can perform binary classification\n",
-    "\n",
-    "    Returns:\n",
-    "        model (keras.Model): classifier model that will \n",
-    "    \"\"\"\n",
-    "    in_layer = Input((28, 28))\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(input_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(x)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Flatten()(x)\n",
-    "    x = Dense(20, activation='relu')\n",
-    "\n",
-    "    x = Dropout(0.9)(x)\n",
-    "    output = Dense(1, activation='sigmoid')(x)\n",
-    "    model = Model(in_layer, x)\n",
-    "    \n",
-    "    return model\n",
-    "    \n",
-    "    return Model(0, 0)\n",
-    "\n",
-    "model = make_model()\n",
-    "loss = tf.losses.BinaryCrossentropy()\n",
-    "optimizer = tf.keras.optimizers.SGD(0.01)\n",
-    "\n",
-    "# Compile tells the keras backend what loss and optimizer to use to perform gradients on the model\n",
-    "# You cannot train a keras model without compiling it first\n",
-    "model.compile(loss=loss, optimizer=optimizer)\n",
-    "\n",
-    "# Show what layers are in the model, and their input and output shapes \n",
-    "# This can help make sure all your stuff is a correct size\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train the model \n",
-    "\n",
-    "We have all the pieces in place:\n",
-    "- [x] Model \n",
-    "- [x] Train Data \n",
-    "- [x] Validation Data \n",
-    "- [x] Loss Function \n",
-    "- [x] Optimizer \n",
-    "\n",
-    "Now lets put this together into a fit model. \n",
-    "Keras trains in place, so you don't need a new variable to hold the `fit_model` vs `model`. \n",
-    "Once you call `fit`, the model is fit, and it re-train, you need to make a new model with the `make_model()` function. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "train_generator_scaled = SkyGenerator(n_samples=1280, pre_processing=processor, batch_size=64)\n",
-    "val_generator_scaled = SkyGenerator(n_samples=12, pre_processing=None, batch_size=64)\n",
-    "\n",
-    "history = model.fit(\n",
-    "    train_generator_scaled, \n",
-    "    validation_data=train_generator_scaled, \n",
-    "    epochs=50, \n",
-    "    verbose=1\n",
-    "    ).history\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Evaluation \n",
-    "\n",
-    "There are some steps we can take to see how well a model trained. \n",
-    "\n",
-    "### Loss Plots \n",
-    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training. \n",
-    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem. \n",
-    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Eval.plot_loss_history(history) \n",
-    "# Eval.plot_history is a simple function \n",
-    "# plots the loss as a function of epoch "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classification Accuracy Plots \n",
-    "\n",
-    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training. \n",
-    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it. \n",
-    "\n",
-    "### ROC\n",
-    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate. \n",
-    "It shows how likely a model is to correctly predict something. \n",
-    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves. \n",
-    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/Roc_curve.svg/800px-Roc_curve.svg.png\" width=\"300\">\n",
-    "\n",
-    "<a href=\"https://upload.wikimedia.org/wikipedia/commons/3/36/Roc-draft-xkcd-style.svg\"></a><a href=\"//commons.wikimedia.org/wiki/File:Roc-draft-xkcd-style.svg#filelinks\" title=\"File:Roc-draft-xkcd-style.svg\">Roc-draft-xkcd-style.svg</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\" title=\"Creative Commons Attribution-Share Alike 4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=109730045\">Link</a>\n",
-    "\n",
-    "\n",
-    "### Confusion Matrix\n",
-    "\n",
-    "Confusion matrices are a great tool for seeing how well each class does against each other. \n",
-    "It gets it name from its ability to tell if a model is \"confusing\" two different classes. \n",
-    "It plots the rate of predicted values for a given class versus the true values. \n",
-    "\n",
-    "<img src=\"https://www.ibm.com/content/dam/connectedassets-adobe-cms/worldwide-content/creative-assets/s-migr/ul/g/c8/a7/binary-matrix.component.complex-narrative-xl.ts=1712087356966.png/content/adobe-cms/us/en/topics/confusion-matrix/jcr:content/root/table_of_contents/body/content_section_styled/content-section-body/complex_narrative_390941229/items/content_group/image\" width='400'>\n",
-    "\n",
-    " <a href=\"https://www.ibm.com/topics/confusion-matrix\">Link</a>\n",
-    "\n",
-    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generator = SkyGenerator(n_samples=1280, train=False, shuffle=True)\n",
-    "\n",
-    "def make_prediction(model, test_generator): \n",
-    "    predictions = trained_model.predict(test_generator)\n",
-    "    prediction_classes = np.where(predictions<0.01, 0, 1)\n",
-    "    labels = test_generator.labels\n",
-    "    return prediction_classes, labels\n",
-    "\n",
-    "def test_quality(prediction, labels): \n",
-    "    accuracy = tf.keras.metrics.BinaryAccuracy()(labels, labels)\n",
-    "    return accuracy.numpy()\n",
-    "\n",
-    "prediction, labels = make_prediction(model, test_generator)\n",
-    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now run them on your own data! \n",
-    "Eval.ROC_curve(prediction, labels)\n",
-    "Eval.confusion_matrix(labels, labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Challenge/challenges/challenge_03.ipynb b/Challenge/challenges/challenge_03.ipynb
deleted file mode 100644
index 284aaec..0000000
--- a/Challenge/challenges/challenge_03.ipynb
+++ /dev/null
@@ -1,540 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Training Challenge! \n",
-    "\n",
-    "In this notebook, there are a whole host of weird errors. \n",
-    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking. \n",
-    "Do your best to sniff out the mistakes in both code and training procedure! \n",
-    "\n",
-    "Your mission, should you choose to accept it, is: \n",
-    "* Work together in groups of 4 to complete this notebook\n",
-    "* Figure out all the coding mistakes and make a notebook that runs\n",
-    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them.\n",
-    "\n",
-    "### Rules \n",
-    "* If you cannot correct the problem, identify it and write a quick paragraph about what you would do\n",
-    "* You are allowed to use any resource you can find; other groups, TA's, a random scientist walking by, and most importantly, the internet. The use of generative AI is highly discouraged - not because it's cheating, but because it can send you down rabbit holes that are hard to find your way out of. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installing the data generation package \n",
-    "! pip install deepbench"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials_2024/main/Challenge/challenge_utilities.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we'll import the different classes from this new file \n",
-    "from challenge_utilities import SkyGenerator03 as SkyGenerator # `as` renames the imported package name\n",
-    "from challenge_utilities import Eval"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you have an issue with this, re-downloading the file may fix it.\n",
-    "If this still doesn't help, [directly pull the file from the github link](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/40758642b5570a3fe53dc49da237a19f5e748a78/07_Challenge/challenge_utilities.py)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Standard packages \n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from tensorflow.keras.layers import Input, Dropout, Conv1D, Dense, AvgPool1D, Flatten\n",
-    "from tensorflow.keras.models import Model\n",
-    "\n",
-    "import tensorflow as tf \n",
-    "from sklearn.preprocessing import MinMaxScaler"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Package documentation \n",
-    "\n",
-    "If you get stuck for syntax or anything - these are the packages used. \n",
-    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names. \n",
-    "\n",
-    "[Numpy]()\n",
-    "\n",
-    "[MatPlotLib]() \n",
-    "\n",
-    "[Tensorflow/tf/Keras]()\n",
-    "\n",
-    "[Sci-kit Learn]()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "label_map = {\n",
-    "    0: \"Star\", \n",
-    "    1: \"Galaxy\"\n",
-    "}\n",
-    "\n",
-    "\n",
-    "def plot_samples(generator, n_columns=3, n_rows=3, label_map=None): \n",
-    "    _, subplots = plt.subplots(n_columns, 1) # Make 9 plots in a 3 x 3 grid \n",
-    "    plt.tight_layout()\n",
-    "    plt.setp(subplots, xticks=[], yticks=[])\n",
-    "\n",
-    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()): \n",
-    "        image, label = generator[sample_index]\n",
-    "        subplot.imshow(image.squeeze()) \n",
-    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels). \n",
-    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-    "        \n",
-    "        string_label = \"??\" \n",
-    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-    "\n",
-    "samples = SkyGenerator(n_samples=9, batch_size=1) # Can just get a few samples\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Look at the input data \n",
-    "\n",
-    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_train_samples = 1280\n",
-    "train_generator = SkyGenerator(n_samples=n_train_samples, shuffle=True)\n",
-    "\n",
-    "n_val_samples = 1280\n",
-    "val_generator = SkyGenerator(n_samples=n_val_samples, train=False, shuffle=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can look at the distribution of labels by grabbing them from the generator \n",
-    "    # TF.Sequence generators supply data as a tuple \n",
-    "    # of (x,y) (or (features, labels)) \n",
-    "    # - so using index 1 we can get the labels\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][1] for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0] for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots.hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.supxlabel(\"Label Distributions\")\n",
-    "figure.supylabel(\"Label Frequency\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can also look at different attributes of the images \n",
-    "# Here, let's look at max values and mean values\n",
-    "\n",
-    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated \n",
-    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().mean() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].mean() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Mean value of pixels in a single image\")\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().max() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].ravel().max() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Max value of pixels in a single image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Processing\n",
-    "\n",
-    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-    "There are near infinite ways to pre-process, especially in the computer vision space. \n",
-    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways. \n",
-    "\n",
-    "For this, let's try bringing all the pixels in the image between 0 and 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "scaler = MinMaxScaler((0, 1))\n",
-    "\n",
-    "fit_data = np.concatenate([train_generator[i][0] for i in range(5)], axis=0) \n",
-    "# This is 5 batches of data, being used to find the approximate min and max of the data\n",
-    "# Because our data is synthetic, we don't need to worry about big outliers\n",
-    "\n",
-    "# Unfortunately, minmaxscaler only handles 1d of data, so we need to do a little pre-and-post processing on the input \n",
-    "# combining the last two dimensions together, making the 2d of the image 1d instead. \n",
-    "fit_data = fit_data.reshape((fit_data.shape[0], fit_data.shape[1]*fit_data.shape[2]) ) \n",
-    "scaler_fit = scaler.fit(fit_data)\n",
-    "\n",
-    "def processor(image): \n",
-    "    # This function will take a single image and return the scaled version \n",
-    "    image_flat = image.ravel() \n",
-    "    image_scaled = scaler_fit.transform(image_flat.reshape(1, -1))\n",
-    "    # Magically reshape it back into 2d \n",
-    "    image_scaled_reshaped = image_scaled.reshape(image.shape)\n",
-    "    return image_scaled_reshaped"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Look at the samples again! \n",
-    "\n",
-    "n_samples = 9\n",
-    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, pre_processing=processor)\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Make the binary classification model \n",
-    "\n",
-    "This function, when called, produces a keras Model instance that you can train to predict a class of an input. \n",
-    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1. \n",
-    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out. \n",
-    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it. \n",
-    "\n",
-    "In this case, what we want: \n",
-    "* Take the input images from the data generator \n",
-    "* Apply two convolutional blocks to the input image \n",
-    "* Decode the second convolution block's output to a probability of the image being a given class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_model(): \n",
-    "    \"\"\"\n",
-    "    Make a network that can perform binary classification\n",
-    "\n",
-    "    Returns:\n",
-    "        model (keras.Model): classifier model that will \n",
-    "    \"\"\"\n",
-    "    in_layer = Input((28, 28))\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(input_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Dense(20, activation='relu')\n",
-    "\n",
-    "    x = Dropout(0.3)(x)\n",
-    "    output = Dense(10, activation='softmax')(x)\n",
-    "    model = Model(in_layer, x)\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "model = make_model()\n",
-    "loss = tf.losses.MeanSquaredError()\n",
-    "optimizer = tf.keras.optimizers.SGD(0.8)\n",
-    "\n",
-    "# Compile tells the keras backend what loss and optimizer to use to perform gradients on the model\n",
-    "# You cannot train a keras model without compiling it first\n",
-    "model.compile(loss=loss, optimizer=optimizer)\n",
-    "\n",
-    "# Show what layers are in the model, and their input and output shapes \n",
-    "# This can help make sure all your stuff is a correct size\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train the model \n",
-    "\n",
-    "We have all the pieces in place:\n",
-    "- [x] Model \n",
-    "- [x] Train Data \n",
-    "- [x] Validation Data \n",
-    "- [x] Loss Function \n",
-    "- [x] Optimizer \n",
-    "\n",
-    "Now lets put this together into a fit model. \n",
-    "Keras trains in place, so you don't need a new variable to hold the `fit_model` vs `model`. \n",
-    "Once you call `fit`, the model is fit, and it re-train, you need to make a new model with the `make_model()` function. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def train_model(model): \n",
-    "    \"\"\"\n",
-    "    Train a model on different training and validation data and show the progress with a plot\n",
-    "\n",
-    "    Args:\n",
-    "        model (keras.Model): Compiled model you want to train with the SkyGenerator data\n",
-    "\n",
-    "    Returns:\n",
-    "        tuple(keras.Model, dict): the trained model object and the history\n",
-    "    \"\"\"\n",
-    "    train_generator = SkyGenerator(n_sample=1280, shuffle=True)\n",
-    "    val_generator = SkyGenerator(n_samples=12, train=False, shuffle=True)\n",
-    "\n",
-    "    history = model.fit(\n",
-    "        train_generator, \n",
-    "        validation_data=train_generator, \n",
-    "        epchs=1, \n",
-    "        verbose=1\n",
-    "        ).history\n",
-    "    \n",
-    "    ########### No Touchie Please ##########\n",
-    "\n",
-    "    loss = history['loss']\n",
-    "    epochs = range(len(loss))\n",
-    "\n",
-    "    val_loss = history['val_loss']\n",
-    "\n",
-    "    plt.plot(epochs, loss, label=\"Train\")\n",
-    "    plt.plot(epochs, val_loss, label='Validation')\n",
-    "\n",
-    "    plt.title(\"Loss History\")\n",
-    "    plt.xlabel(\"Epoch\")\n",
-    "    plt.ylabel(\"Loss\")\n",
-    "    plt.legend()\n",
-    "    plt.show()\n",
-    "    \n",
-    "    #####################\n",
-    "\n",
-    "    return model, history"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "train_generator_scaled = SkyGenerator(n_samples=1280, pre_processing=processor, batch_size=64)\n",
-    "val_generator_scaled = SkyGenerator(n_samples=12, pre_processing=None, batch_size=64)\n",
-    "\n",
-    "history = model.fit(\n",
-    "    train_generator_scaled, \n",
-    "    validation_data=train_generator_scaled, \n",
-    "    epchs=1, \n",
-    "    verbose=1\n",
-    "    ).history\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Evaluation \n",
-    "\n",
-    "There are some steps we can take to see how well a model trained. \n",
-    "\n",
-    "### Loss Plots \n",
-    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training. \n",
-    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem. \n",
-    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Eval.plot_loss_history(history) \n",
-    "# Eval.plot_history is a simple function \n",
-    "# plots the loss as a function of epoch "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classification Accuracy Plots \n",
-    "\n",
-    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training. \n",
-    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it. \n",
-    "\n",
-    "### ROC\n",
-    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate. \n",
-    "It shows how likely a model is to correctly predict something. \n",
-    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves. \n",
-    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/Roc_curve.svg/800px-Roc_curve.svg.png\" width=\"300\">\n",
-    "\n",
-    "<a href=\"https://upload.wikimedia.org/wikipedia/commons/3/36/Roc-draft-xkcd-style.svg\"></a><a href=\"//commons.wikimedia.org/wiki/File:Roc-draft-xkcd-style.svg#filelinks\" title=\"File:Roc-draft-xkcd-style.svg\">Roc-draft-xkcd-style.svg</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\" title=\"Creative Commons Attribution-Share Alike 4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=109730045\">Link</a>\n",
-    "\n",
-    "\n",
-    "### Confusion Matrix\n",
-    "\n",
-    "Confusion matrices are a great tool for seeing how well each class does against each other. \n",
-    "It gets it name from its ability to tell if a model is \"confusing\" two different classes. \n",
-    "It plots the rate of predicted values for a given class versus the true values. \n",
-    "\n",
-    "<img src=\"https://www.ibm.com/content/dam/connectedassets-adobe-cms/worldwide-content/creative-assets/s-migr/ul/g/c8/a7/binary-matrix.component.complex-narrative-xl.ts=1712087356966.png/content/adobe-cms/us/en/topics/confusion-matrix/jcr:content/root/table_of_contents/body/content_section_styled/content-section-body/complex_narrative_390941229/items/content_group/image\" width='400'>\n",
-    "\n",
-    " <a href=\"https://www.ibm.com/topics/confusion-matrix\">Link</a>\n",
-    "\n",
-    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generator = SkyGenerator(n_samples=1280, train=False, shuffle=True)\n",
-    "\n",
-    "def make_prediction(model, test_generator): \n",
-    "    predictions = trained_model.predict(test_generator)\n",
-    "    prediction_classes = np.where(predictions<0.5, 0, 1)\n",
-    "    labels = test_generator.labels\n",
-    "    return prediction_classes, labels\n",
-    "\n",
-    "def test_quality(prediction, labels): \n",
-    "    accuracy = tf.keras.metrics.BinaryAccuracy()(labels, labels)\n",
-    "    return accuracy.numpy()\n",
-    "\n",
-    "prediction, labels = make_prediction(model, test_generator)\n",
-    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now run them on your own data! \n",
-    "Eval.ROC_curve(prediction, labels)\n",
-    "Eval.confusion_matrix(labels, labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Challenge/challenges/challenge_04.ipynb b/Challenge/challenges/challenge_04.ipynb
deleted file mode 100644
index 365a648..0000000
--- a/Challenge/challenges/challenge_04.ipynb
+++ /dev/null
@@ -1,499 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Training Challenge! \n",
-    "\n",
-    "In this notebook, there are a whole host of weird errors. \n",
-    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking. \n",
-    "Do your best to sniff out the mistakes in both code and training procedure! \n",
-    "\n",
-    "Your mission, should you choose to accept it, is: \n",
-    "* Work together in groups of 4 to complete this notebook\n",
-    "* Figure out all the coding mistakes and make a notebook that runs\n",
-    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them.\n",
-    "\n",
-    "### Rules \n",
-    "* If you cannot correct the problem, identify it and write a quick paragraph about what you would do\n",
-    "* You are allowed to use any resource you can find; other groups, TA's, a random scientist walking by, and most importantly, the internet. The use of generative AI is highly discouraged - not because it's cheating, but because it can send you down rabbit holes that are hard to find your way out of. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installing the data generation package \n",
-    "! pip install deepbench"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials_2024/main/Challenge/challenge_utilities.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we'll import the different classes from this new file \n",
-    "from challenge_utilities import SkyGenerator04 as SkyGenerator # `as` renames the imported package name\n",
-    "from challenge_utilities import Eval"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you have an issue with this, re-downloading the file may fix it.\n",
-    "If this still doesn't help, [directly pull the file from the github link](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/40758642b5570a3fe53dc49da237a19f5e748a78/07_Challenge/challenge_utilities.py)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Standard packages \n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from tensorflow.keras.layers import Input, Dropout, Conv1D, Dense, AvgPool1D, Flatten\n",
-    "from tensorflow.keras.models import Model\n",
-    "\n",
-    "import tensorflow as tf \n",
-    "from sklearn.preprocessing import MinMaxScaler"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Package documentation \n",
-    "\n",
-    "If you get stuck for syntax or anything - these are the packages used. \n",
-    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names. \n",
-    "\n",
-    "[Numpy]()\n",
-    "\n",
-    "[MatPlotLib]() \n",
-    "\n",
-    "[Tensorflow/tf/Keras]()\n",
-    "\n",
-    "[Sci-kit Learn]()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "label_map = {\n",
-    "    0: \"Star\", \n",
-    "    1: \"Galaxy\"\n",
-    "}\n",
-    "\n",
-    "\n",
-    "def plot_samples(generator, n_columns=3, n_rows=3, label_map=None): \n",
-    "    _, subplots = plt.subplots(n_columns, 1) # Make 9 plots in a 3 x 3 grid \n",
-    "    plt.tight_layout()\n",
-    "    plt.setp(subplots, xticks=[], yticks=[])\n",
-    "\n",
-    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()): \n",
-    "        image, label = generator[sample_index]\n",
-    "        subplot.imshow(image.squeeze()) \n",
-    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels). \n",
-    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-    "        \n",
-    "        string_label = \"??\" \n",
-    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-    "\n",
-    "samples = SkyGenerator(n_samples=9, batch_size=1) # Can just get a few samples\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Look at the input data \n",
-    "\n",
-    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_train_samples = 1280\n",
-    "train_generator = SkyGenerator(n_samples=n_train_samples, shuffle=True)\n",
-    "\n",
-    "n_val_samples = 1280\n",
-    "val_generator = SkyGenerator(n_samples=n_val_samples, train=False, shuffle=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can look at the distribution of labels by grabbing them from the generator \n",
-    "    # TF.Sequence generators supply data as a tuple \n",
-    "    # of (x,y) (or (features, labels)) \n",
-    "    # - so using index 1 we can get the labels\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][1] for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0] for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots.hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.supxlabel(\"Label Distributions\")\n",
-    "figure.supylabel(\"Label Frequency\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can also look at different attributes of the images \n",
-    "# Here, let's look at max values and mean values\n",
-    "\n",
-    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated \n",
-    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().mean() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].mean() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Mean value of pixels in a single image\")\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().max() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].ravel().max() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Max value of pixels in a single image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Processing\n",
-    "\n",
-    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-    "There are near infinite ways to pre-process, especially in the computer vision space. \n",
-    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways. \n",
-    "\n",
-    "For this, let's try bringing all the pixels in the image between 0 and 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "scaler = MinMaxScaler((0, 1))\n",
-    "\n",
-    "fit_data = np.concatenate([train_generator[i][0] for i in range(5)], axis=0) \n",
-    "# This is 5 batches of data, being used to find the approximate min and max of the data\n",
-    "# Because our data is synthetic, we don't need to worry about big outliers\n",
-    "\n",
-    "# Unfortunately, minmaxscaler only handles 1d of data, so we need to do a little pre-and-post processing on the input \n",
-    "# combining the last two dimensions together, making the 2d of the image 1d instead. \n",
-    "fit_data = fit_data.reshape((fit_data.shape[0], fit_data.shape[1]*fit_data.shape[2]) ) \n",
-    "scaler_fit = scaler.fit(fit_data)\n",
-    "\n",
-    "def processor(image): \n",
-    "    # This function will take a single image and return the scaled version \n",
-    "    image_flat = image.ravel() \n",
-    "    image_scaled = scaler_fit.transform(image_flat.reshape(1, -1))\n",
-    "    # Magically reshape it back into 2d \n",
-    "    image_scaled_reshaped = image_scaled.reshape(image.shape)\n",
-    "    return image_scaled_reshaped"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Look at the samples again! \n",
-    "\n",
-    "n_samples = 9\n",
-    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, pre_processing=processor)\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Make the binary classification model \n",
-    "\n",
-    "This function, when called, produces a keras Model instance that you can train to predict a class of an input. \n",
-    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1. \n",
-    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out. \n",
-    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it. \n",
-    "\n",
-    "In this case, what we want: \n",
-    "* Take the input images from the data generator \n",
-    "* Apply two convolutional blocks to the input image \n",
-    "* Decode the second convolution block's output to a probability of the image being a given class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_model(): \n",
-    "    \"\"\"\n",
-    "    Make a network that can perform binary classification\n",
-    "\n",
-    "    Returns:\n",
-    "        model (keras.Model): classifier model that will \n",
-    "    \"\"\"\n",
-    "    in_layer = Input((28, 28))\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(input_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(x)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "\n",
-    "    x = Dense(20, activation='relu')\n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Flatten()(x)\n",
-    "\n",
-    "    x = Dropout(0.3)(x)\n",
-    "    output = Dense(10, activation='sigmoid')(x)\n",
-    "    model = Model(in_layer, x)\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "model = make_model()\n",
-    "loss = tf.losses.BinaryCrossropy()\n",
-    "optimizer = tf.keras.optimizers.aDAM(0.01)\n",
-    "\n",
-    "# Compile tells the keras backend what loss and optimizer to use to perform gradients on the model\n",
-    "# You cannot train a keras model without compiling it first\n",
-    "model.compile(loss=loss, optimizer=optimizer)\n",
-    "\n",
-    "# Show what layers are in the model, and their input and output shapes \n",
-    "# This can help make sure all your stuff is a correct size\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train the model \n",
-    "\n",
-    "We have all the pieces in place:\n",
-    "- [x] Model \n",
-    "- [x] Train Data \n",
-    "- [x] Validation Data \n",
-    "- [x] Loss Function \n",
-    "- [x] Optimizer \n",
-    "\n",
-    "Now lets put this together into a fit model. \n",
-    "Keras trains in place, so you don't need a new variable to hold the `fit_model` vs `model`. \n",
-    "Once you call `fit`, the model is fit, and it re-train, you need to make a new model with the `make_model()` function. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_generator_scaled = SkyGenerator(n_samples=1280, pre_processing=processor, batch_size=64)\n",
-    "val_generator_scaled = SkyGenerator(n_samples=12, pre_processing=None, batch_size=64)\n",
-    "\n",
-    "history = model.fit(\n",
-    "    train_generator_scaled, \n",
-    "    validation_data=train_generator_scaled, \n",
-    "    epchs=1, \n",
-    "    verbose=1\n",
-    "    ).history"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Evaluation \n",
-    "\n",
-    "There are some steps we can take to see how well a model trained. \n",
-    "\n",
-    "### Loss Plots \n",
-    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training. \n",
-    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem. \n",
-    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Eval.plot_loss_history(history) \n",
-    "# Eval.plot_history is a simple function \n",
-    "# plots the loss as a function of epoch "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classification Accuracy Plots \n",
-    "\n",
-    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training. \n",
-    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it. \n",
-    "\n",
-    "### ROC\n",
-    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate. \n",
-    "It shows how likely a model is to correctly predict something. \n",
-    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves. \n",
-    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/Roc_curve.svg/800px-Roc_curve.svg.png\" width=\"300\">\n",
-    "\n",
-    "<a href=\"https://upload.wikimedia.org/wikipedia/commons/3/36/Roc-draft-xkcd-style.svg\"></a><a href=\"//commons.wikimedia.org/wiki/File:Roc-draft-xkcd-style.svg#filelinks\" title=\"File:Roc-draft-xkcd-style.svg\">Roc-draft-xkcd-style.svg</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\" title=\"Creative Commons Attribution-Share Alike 4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=109730045\">Link</a>\n",
-    "\n",
-    "\n",
-    "### Confusion Matrix\n",
-    "\n",
-    "Confusion matrices are a great tool for seeing how well each class does against each other. \n",
-    "It gets it name from its ability to tell if a model is \"confusing\" two different classes. \n",
-    "It plots the rate of predicted values for a given class versus the true values. \n",
-    "\n",
-    "<img src=\"https://www.ibm.com/content/dam/connectedassets-adobe-cms/worldwide-content/creative-assets/s-migr/ul/g/c8/a7/binary-matrix.component.complex-narrative-xl.ts=1712087356966.png/content/adobe-cms/us/en/topics/confusion-matrix/jcr:content/root/table_of_contents/body/content_section_styled/content-section-body/complex_narrative_390941229/items/content_group/image\" width='400'>\n",
-    "\n",
-    " <a href=\"https://www.ibm.com/topics/confusion-matrix\">Link</a>\n",
-    "\n",
-    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generator = SkyGenerator(n_samples=1280, train=False, shuffle=True)\n",
-    "\n",
-    "def make_prediction(model, test_generator): \n",
-    "    predictions = trained_model.predict(test_generator)\n",
-    "    prediction_classes = np.where(predictions<0.5, 0, 1)\n",
-    "    labels = test_generator.labels\n",
-    "    return prediction_classes, labels\n",
-    "\n",
-    "def test_quality(prediction, labels): \n",
-    "    accuracy = tf.keras.metrics.BinaryAccuracy()(labels, labels)\n",
-    "    return accuracy.numpy()\n",
-    "\n",
-    "prediction, labels = make_prediction(model, test_generator)\n",
-    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now run them on your own data! \n",
-    "Eval.ROC_curve(prediction, labels)\n",
-    "Eval.confusion_matrix(labels, labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Challenge/challenges/challenge_05.ipynb b/Challenge/challenges/challenge_05.ipynb
deleted file mode 100644
index dc1d7ed..0000000
--- a/Challenge/challenges/challenge_05.ipynb
+++ /dev/null
@@ -1,501 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Training Challenge! \n",
-    "\n",
-    "In this notebook, there are a whole host of weird errors. \n",
-    "Some of them will be obvious and throw an error, but some are less clear and will break things without telling you they're breaking. \n",
-    "Do your best to sniff out the mistakes in both code and training procedure! \n",
-    "\n",
-    "Your mission, should you choose to accept it, is: \n",
-    "* Work together in groups of 4 to complete this notebook\n",
-    "* Figure out all the coding mistakes and make a notebook that runs\n",
-    "* Find the mistakes in training and take appropriate corrective measures so the model trains well!\n",
-    "* Make a ~15 minute long presentation showing your results and the steps you took to find and solve them.\n",
-    "\n",
-    "### Rules \n",
-    "* If you cannot correct the problem, identify it and write a quick paragraph about what you would do\n",
-    "* You are allowed to use any resource you can find; other groups, TA's, a random scientist walking by, and most importantly, the internet. The use of generative AI is highly discouraged - not because it's cheating, but because it can send you down rabbit holes that are hard to find your way out of. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installing the data generation package \n",
-    "! pip install deepbench"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! curl -o challenge_utilities.py https://raw.githubusercontent.com/BNL-Fermilab-RENEW/tutorials_2024/main/Challenge/challenge_utilities.py"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you have an issue with this, re-downloading the file may fix it.\n",
-    "If this still doesn't help, [directly pull the file from the github link](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/40758642b5570a3fe53dc49da237a19f5e748a78/07_Challenge/challenge_utilities.py)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we'll import the different classes from this new file \n",
-    "from challenge_utilities import SkyGenerator05 as SkyGenerator # `as` renames the imported package name\n",
-    "from challenge_utilities import Eval"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Standard packages \n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from tensorflow.keras.layers import Input, Dropout, Conv1D, Dense, AvgPool1D, Flatten\n",
-    "from tensorflow.keras.models import Model\n",
-    "\n",
-    "import tensorflow as tf \n",
-    "from sklearn.preprocessing import MinMaxScaler\n",
-    "from sklearn.decomposition import PCA"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Package documentation \n",
-    "\n",
-    "If you get stuck for syntax or anything - these are the packages used. \n",
-    "Look up a function you're trying to use in their package search pages, and see if you maybe have types wrong, or wrong variable names. \n",
-    "\n",
-    "[Numpy]()\n",
-    "\n",
-    "[MatPlotLib]() \n",
-    "\n",
-    "[Tensorflow/tf/Keras]()\n",
-    "\n",
-    "[Sci-kit Learn]()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "label_map = {\n",
-    "    0: \"Star\", \n",
-    "    1: \"Galaxy\"\n",
-    "}\n",
-    "\n",
-    "\n",
-    "def plot_samples(generator, n_columns=3, n_rows=3, label_map=None): \n",
-    "    _, subplots = plt.subplots(n_columns, 1) # Make 9 plots in a 3 x 3 grid \n",
-    "    plt.tight_layout()\n",
-    "    plt.setp(subplots, xticks=[], yticks=[])\n",
-    "\n",
-    "    for sample_index, subplot in zip(range(n_columns*n_rows), subplots.ravel()): \n",
-    "        image, label = generator[sample_index]\n",
-    "        subplot.imshow(image.squeeze()) \n",
-    "        # 'imshow' displays an image in 2d (black and white if it only has 1 color channel, or in color if it has 3 (r,g,b) color channels). \n",
-    "        # Here it's green and blue because the default colorway for matplotlib is \"viridis\", with is all cool colors\n",
-    "        \n",
-    "        string_label = \"??\" \n",
-    "        subplot.set_xlabel(string_label) # This gives you a label underneath the image (on the x axis)\n",
-    "\n",
-    "samples = SkyGenerator(n_samples=9, batch_size=1) # Can just get a few samples\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Look at the input data \n",
-    "\n",
-    "Understanding the data is a critical part of the training process, let's take a look at the distributions we're working with. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_train_samples = 1280\n",
-    "train_generator = SkyGenerator(n_samples=n_train_samples, shuffle=True)\n",
-    "\n",
-    "n_val_samples = 1280\n",
-    "val_generator = SkyGenerator(n_samples=n_val_samples, train=False, shuffle=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can look at the distribution of labels by grabbing them from the generator \n",
-    "    # TF.Sequence generators supply data as a tuple \n",
-    "    # of (x,y) (or (features, labels)) \n",
-    "    # - so using index 1 we can get the labels\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][1] for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0] for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots.hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.supxlabel(\"Label Distributions\")\n",
-    "figure.supylabel(\"Label Frequency\")\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can also look at different attributes of the images \n",
-    "# Here, let's look at max values and mean values\n",
-    "\n",
-    "# These numbers will be slightly different every time, there's randomness controlling how the images are generated \n",
-    "# In scientific settings, it's good to remove the randomness if possible, but here it's fine\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().mean() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].mean() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Mean value of pixels in a single image\")\n",
-    "plt.show()\n",
-    "\n",
-    "\n",
-    "all_train_labels = np.array([\n",
-    "    train_generator[i][0].ravel().max() for i in range(len(train_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "all_val_labels = np.array([\n",
-    "    val_generator[i][0].ravel().max() for i in range(len(val_generator))\n",
-    "]).ravel()\n",
-    "\n",
-    "figure, subplots = plt.subplots(1, 2)\n",
-    "subplots[0].hist(all_train_labels)\n",
-    "subplots[0].set_xlabel(\"Train\")\n",
-    "\n",
-    "subplots[1].hist(all_val_labels)\n",
-    "subplots[1].set_xlabel(\"Validation\")\n",
-    "\n",
-    "figure.suptitle(\"Max value of pixels in a single image\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Processing\n",
-    "\n",
-    "There are many ways to help a model along when it comes to training - one of those is data pre-processing.\n",
-    "There are near infinite ways to pre-process, especially in the computer vision space. \n",
-    "Think about it like applying different instagram filters, they have different impacts that emphasis the image in different ways. \n",
-    "\n",
-    "For this, let's try bringing all the pixels in the image between 0 and 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "scaler = MinMaxScaler((0, 1))\n",
-    "\n",
-    "fit_data = np.concatenate([train_generator[i][0] for i in range(5)], axis=0) \n",
-    "# This is 5 batches of data, being used to find the approximate min and max of the data\n",
-    "# Because our data is synthetic, we don't need to worry about big outliers\n",
-    "\n",
-    "# Unfortunately, minmaxscaler only handles 1d of data, so we need to do a little pre-and-post processing on the input \n",
-    "# combining the last two dimensions together, making the 2d of the image 1d instead. \n",
-    "fit_data = fit_data.reshape((fit_data.shape[0], fit_data.shape[1]*fit_data.shape[2]) ) \n",
-    "scaler_fit = scaler.fit(fit_data)\n",
-    "\n",
-    "def processor(image): \n",
-    "    # This function will take a single image and return the scaled version \n",
-    "    image_flat = image.ravel() \n",
-    "    image_scaled = scaler_fit.transform(image_flat.reshape(1, -1))\n",
-    "    # Magically reshape it back into 2d \n",
-    "    image_scaled_reshaped = image_scaled.reshape(image.shape)\n",
-    "    return image_scaled_reshaped\n",
-    "\n",
-    "# We can also use PCA decomposition to reduce the dimension of the data if we want\n",
-    "generator_sample = SkyGenerator(n_samples=20)\n",
-    "generator_sample = [generator_sample.__getitem__(index)[0] for  index in range(20)]\n",
-    "decomposition = PCA(n_components=16).fit(generator_sample)\n",
-    "\n",
-    "def pca_processor(image): \n",
-    "    return decomposition.transform(image)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Look at the samples again! \n",
-    "\n",
-    "n_samples = 9\n",
-    "samples = SkyGenerator(n_samples=n_samples, batch_size=1, pre_processing=processor)\n",
-    "plot_samples(samples)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Make the binary classification model \n",
-    "\n",
-    "This function, when called, produces a keras Model instance that you can train to predict a class of an input. \n",
-    "Because this is a binary predictor, it can be used to pick if an image is closer to being class 0 or class 1. \n",
-    "It takes an input of a certain shape, (defined by the `in_layer`), fits it to a convolution operation, and gives you a number (or array!) back out. \n",
-    "The way this becomes a predictive engine is through the loss, of the output of the model will minimize a loss function, and give us a prediction that matches the data we fed it. \n",
-    "\n",
-    "In this case, what we want: \n",
-    "* Take the input images from the data generator \n",
-    "* Apply two convolutional blocks to the input image \n",
-    "* Decode the second convolution block's output to a probability of the image being a given class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_model(): \n",
-    "    \"\"\"\n",
-    "    Make a network that can perform binary classification\n",
-    "\n",
-    "    Returns:\n",
-    "        model (keras.Model): classifier model that will \n",
-    "    \"\"\"\n",
-    "    in_layer = Input((4, 4))\n",
-    "    x = Conv1D(filters=4, kernel_size=2)(input_layer)\n",
-    "    x = Conv1D(filters=8, kernel_size=4)(x)\n",
-    "    x = Conv1D(filters=12, kernel_size=6)(x)\n",
-    "    \n",
-    "    x = AvgPool1D(6)(x)\n",
-    "\n",
-    "    x = Dense(20, activation='relu')\n",
-    "\n",
-    "    x = Dropout(0.3)(x)\n",
-    "    output = Dense(10, activation='softmax')(x)\n",
-    "    model = Model(in_layer, x)\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "model = make_model()\n",
-    "loss = tf.losses.BinaryCrossentropy()\n",
-    "optimizer = tf.keras.optimizers.SGD(0.0001)\n",
-    "\n",
-    "# Compile tells the keras backend what loss and optimizer to use to perform gradients on the model\n",
-    "# You cannot train a keras model without compiling it first\n",
-    "model.compile(loss=loss, optimizer=optimizer)\n",
-    "\n",
-    "# Show what layers are in the model, and their input and output shapes \n",
-    "# This can help make sure all your stuff is a correct size\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Train the model \n",
-    "\n",
-    "We have all the pieces in place:\n",
-    "- [x] Model \n",
-    "- [x] Train Data \n",
-    "- [x] Validation Data \n",
-    "- [x] Loss Function \n",
-    "- [x] Optimizer \n",
-    "\n",
-    "Now lets put this together into a fit model. \n",
-    "Keras trains in place, so you don't need a new variable to hold the `fit_model` vs `model`. \n",
-    "Once you call `fit`, the model is fit, and it re-train, you need to make a new model with the `make_model()` function. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_generator_scaled = SkyGenerator(n_samples=1280, pre_processing=pca_processor, batch_size=64)\n",
-    "val_generator_scaled = SkyGenerator(n_samples=12, pre_processing=processor, batch_size=64)\n",
-    "\n",
-    "history = model.fit(\n",
-    "    train_generator_scaled, \n",
-    "    validation_data=train_generator_scaled, \n",
-    "    epchs=1, \n",
-    "    verbose=1\n",
-    "    ).history"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Evaluation \n",
-    "\n",
-    "There are some steps we can take to see how well a model trained. \n",
-    "\n",
-    "### Loss Plots \n",
-    "Obvious one is to see how the loss progressed - if the loss was still trending down when the training stopped, it would make sense that the model would benefit from longer training. \n",
-    "Or, if the loss never moves or blows up entirely, that's a sign there's a problem. \n",
-    "Looking at the [common pitfalls notebook](https://github.com/BNL-Fermilab-RENEW/tutorials_2024/blob/main/07_Challenge/common_pitfalls.ipynb) may help diagnose your problems! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Eval.plot_loss_history(history) \n",
-    "# Eval.plot_history is a simple function \n",
-    "# plots the loss as a function of epoch "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Classification Accuracy Plots \n",
-    "\n",
-    "After we did all this work to train a model, we need to be able to report how good it is on data we didn't use in training. \n",
-    "For this, we'll make a new set of data (or use some data we held out from training), and run a few evaluation metrics on it. \n",
-    "\n",
-    "### ROC\n",
-    "The `receiver operating characteristic curve` (or just \"ROC\" (pronounced \"Rock\") Curve) is a metric that plots the true positive rate against the false positive rate. \n",
-    "It shows how likely a model is to correctly predict something. \n",
-    "The idea is that a classifier a better classifier will have lower false positive rate, and a higher true positive rate, so the curve will get closer and closer to the upper left corner as the prediction improves. \n",
-    "\n",
-    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/13/Roc_curve.svg/800px-Roc_curve.svg.png\" width=\"300\">\n",
-    "\n",
-    "<a href=\"https://upload.wikimedia.org/wikipedia/commons/3/36/Roc-draft-xkcd-style.svg\"></a><a href=\"//commons.wikimedia.org/wiki/File:Roc-draft-xkcd-style.svg#filelinks\" title=\"File:Roc-draft-xkcd-style.svg\">Roc-draft-xkcd-style.svg</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\" title=\"Creative Commons Attribution-Share Alike 4.0\">CC BY-SA 4.0</a>, <a href=\"https://commons.wikimedia.org/w/index.php?curid=109730045\">Link</a>\n",
-    "\n",
-    "\n",
-    "### Confusion Matrix\n",
-    "\n",
-    "Confusion matrices are a great tool for seeing how well each class does against each other. \n",
-    "It gets it name from its ability to tell if a model is \"confusing\" two different classes. \n",
-    "It plots the rate of predicted values for a given class versus the true values. \n",
-    "\n",
-    "<img src=\"https://www.ibm.com/content/dam/connectedassets-adobe-cms/worldwide-content/creative-assets/s-migr/ul/g/c8/a7/binary-matrix.component.complex-narrative-xl.ts=1712087356966.png/content/adobe-cms/us/en/topics/confusion-matrix/jcr:content/root/table_of_contents/body/content_section_styled/content-section-body/complex_narrative_390941229/items/content_group/image\" width='400'>\n",
-    "\n",
-    " <a href=\"https://www.ibm.com/topics/confusion-matrix\">Link</a>\n",
-    "\n",
-    " A good confusion matrix will have very high values in the green boxes, and lower values in the red boxes. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generator = SkyGenerator(n_samples=1280, train=False, shuffle=True)\n",
-    "\n",
-    "def make_prediction(model, test_generator): \n",
-    "    predictions = trained_model.predict(test_generator)\n",
-    "    prediction_classes = np.where(predictions<0.5, 0, 1)\n",
-    "    labels = test_generator.labels\n",
-    "    return prediction_classes, labels\n",
-    "\n",
-    "def test_quality(prediction, labels): \n",
-    "    accuracy = tf.keras.metrics.BinaryAccuracy()(labels, labels)\n",
-    "    return accuracy.numpy()\n",
-    "\n",
-    "prediction, labels = make_prediction(model, test_generator)\n",
-    "print(f\"The binary classification accuracy on the test set is: {test_quality(prediction, labels)}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now run them on your own data! \n",
-    "Eval.ROC_curve(prediction, labels)\n",
-    "Eval.confusion_matrix(labels, labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}