diff --git a/docs/_static/HyraxCNN_vs_VGG11.png b/docs/_static/HyraxCNN_vs_VGG11.png
new file mode 100644
index 0000000..69050c2
Binary files /dev/null and b/docs/_static/HyraxCNN_vs_VGG11.png differ
diff --git a/docs/notebooks.rst b/docs/notebooks.rst
index 7f7e544..e842cac 100644
--- a/docs/notebooks.rst
+++ b/docs/notebooks.rst
@@ -2,5 +2,3 @@ Notebooks
 ========================================================================================
 
 .. toctree::
-
-    Introducing Jupyter Notebooks <notebooks/intro_notebook>
diff --git a/docs/notebooks/intro_notebook.ipynb b/docs/notebooks/intro_notebook.ipynb
deleted file mode 100644
index 0589b29..0000000
--- a/docs/notebooks/intro_notebook.ipynb
+++ /dev/null
@@ -1,84 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "textblock1",
-   "metadata": {
-    "cell_marker": "\"\"\""
-   },
-   "source": [
-    "# Introducing Jupyter Notebooks in Sphinx\n",
-    "\n",
-    "This notebook showcases very basic functionality of rendering your jupyter notebooks as tutorials inside your sphinx documentation.\n",
-    "\n",
-    "As part of the LINCC Frameworks python project template, your notebooks will be executed AND rendered at document build time.\n",
-    "\n",
-    "You can read more about Sphinx, ReadTheDocs, and building notebooks in [LINCC's documentation](https://lincc-ppt.readthedocs.io/en/latest/practices/sphinx.html)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "codeblock1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def sierpinsky(order):\n",
-    "    \"\"\"Define a method that will create a Sierpinsky triangle of given order,\n",
-    "    and will print it out.\"\"\"\n",
-    "    triangles = [\"*\"]\n",
-    "    for i in range(order):\n",
-    "        spaces = \" \" * (2**i)\n",
-    "        triangles = [spaces + triangle + spaces for triangle in triangles] + [\n",
-    "            triangle + \" \" + triangle for triangle in triangles\n",
-    "        ]\n",
-    "    print(f\"Printing order {order} triangle\")\n",
-    "    print(\"\\n\".join(triangles))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "textblock2",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 1
-   },
-   "source": [
-    "Then, call our method a few times. This will happen on the fly during notebook rendering."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "codeblock2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for order in range(3):\n",
-    "    sierpinsky(order)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "codeblock3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sierpinsky(4)"
-   ]
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "cell_markers": "\"\"\""
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/docs/pre_executed/external_dataset_and_model_training_example.ipynb b/docs/pre_executed/external_dataset_and_model_training_example.ipynb
new file mode 100644
index 0000000..9f63825
--- /dev/null
+++ b/docs/pre_executed/external_dataset_and_model_training_example.ipynb
@@ -0,0 +1,296 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "42dfb8e1",
+   "metadata": {},
+   "source": [
+    "# External Dataset and Model Usage Example\n",
+    "\n",
+    "This notebook demonstrates how to use dataset and model classes **defined outside of the Hyrax package** within Hyrax's training pipeline. It covers:\n",
+    "\n",
+    "- Loading the [Galaxy10 dataset](https://astronn.readthedocs.io/en/stable/galaxy10sdss.html) via a custom `HyraxDataset` subclass (`Galaxy10Dataset`)\n",
+    "- Training Hyrax's built-in `HyraxCNN` model on that dataset\n",
+    "- Training a locally-defined `VGG11` model (registered with Hyrax) on the same dataset\n",
+    "- Comparing training loss between the two models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "411d03bc",
+   "metadata": {},
+   "source": [
+    "## Download the Galaxy10 Dataset\n",
+    "\n",
+    "The [Galaxy10 dataset](https://astronn.readthedocs.io/en/stable/galaxy10sdss.html) from [AstroNN](https://github.com/henrysky/astroNN) contains ~22k labeled galaxy images across 10 morphological classes. It serves as a stand-in for any external astronomical image dataset.\n",
+    "\n",
+    "The ~200MB HDF5 file will be downloaded and cached locally via `pooch`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c5817aa3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pooch\n",
+    "\n",
+    "file_path = pooch.retrieve(\n",
+    "    url=\"http://www.astro.utoronto.ca/~bovy/Galaxy10/Galaxy10.h5\",\n",
+    "    known_hash=\"sha256:969A6B1CEFCC36E09FFFA86FEBD2F699A4AA19B837BA0427F01B0BC6DED458AF\",\n",
+    "    fname=\"Galaxy10.h5\",\n",
+    "    path=\"./data/galaxy_10\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c027bd3b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from hyrax import Hyrax\n",
+    "\n",
+    "h = Hyrax()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff9b0ab4",
+   "metadata": {},
+   "source": [
+    "## Configure Hyrax\n",
+    "\n",
+    "Next we build a `data_request` dictionary that tells Hyrax which dataset class to use, where the data lives, and how to split it between training (80%) and validation (20%).\n",
+    "\n",
+    "The key here is `dataset_class` — instead of a built-in Hyrax dataset, we point it at our locally-defined `Galaxy10Dataset` class. Hyrax will import and instantiate it automatically.\n",
+    "\n",
+    "We also set `channels_first: True` in the dataset config so the images are provided in `(C, H, W)` order as expected by PyTorch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e144812",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_request = {\n",
+    "    \"train\": {\n",
+    "        \"data\": {\n",
+    "            \"dataset_class\": \"external_hyrax_example.datasets.galaxy10_dataset.Galaxy10Dataset\",\n",
+    "            \"data_location\": \"./data/galaxy_10\",\n",
+    "            \"fields\": [\"image\", \"label\"],\n",
+    "            \"primary_id_field\": \"object_id\",\n",
+    "            \"split_fraction\": 0.8,\n",
+    "            \"dataset_config\": {\n",
+    "                \"external_hyrax_example\": {\n",
+    "                    \"galaxy10_dataset\": {\n",
+    "                        \"channels_first\": True,\n",
+    "                    },\n",
+    "                },\n",
+    "            },\n",
+    "        },\n",
+    "    },\n",
+    "    \"validate\": {\n",
+    "        \"data\": {\n",
+    "            \"dataset_class\": \"external_hyrax_example.datasets.galaxy10_dataset.Galaxy10Dataset\",\n",
+    "            \"data_location\": \"./data/galaxy_10\",\n",
+    "            \"fields\": [\"image\", \"label\"],\n",
+    "            \"primary_id_field\": \"object_id\",\n",
+    "            \"split_fraction\": 0.2,\n",
+    "            \"dataset_config\": {\n",
+    "                \"external_hyrax_example\": {\n",
+    "                    \"galaxy10_dataset\": {\n",
+    "                        \"channels_first\": True,\n",
+    "                    },\n",
+    "                },\n",
+    "            },\n",
+    "        },\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "h.set_config(\"data_request\", data_request)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b53b5634",
+   "metadata": {},
+   "source": [
+    "## Train HyraxCNN\n",
+    "\n",
+    "We'll start by training `HyraxCNN`, a lightweight CNN that ships with Hyrax. To do so, we need to set the model name in config."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f37265bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h.set_config(\"model.name\", \"HyraxCNN\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ce9b22cf",
+   "metadata": {},
+   "source": [
+    "HyraxCNN's default `prepare_inputs` expects images in `(C, H, W)` format with standard normalization. Because Galaxy10 images are already in `(C, H, W)` order (we set `channels_first: True` earlier), we override `prepare_inputs` to apply the correct normalization and extract the label — replacing the default implementation before training begins."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cbc62ec9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@staticmethod\n",
+    "def prepare_inputs(data_dict):\n",
+    "    import numpy as np\n",
+    "\n",
+    "    if \"data\" not in data_dict:\n",
+    "        raise RuntimeError(\"Unable to find `data` key in data_dict\")\n",
+    "\n",
+    "    data = data_dict[\"data\"]\n",
+    "    image = np.asarray(data[\"image\"], dtype=np.float32)\n",
+    "\n",
+    "    # normalize the image to have mean 0.5 and std 0.5\n",
+    "    image = np.asarray(image, dtype=np.float32)\n",
+    "    mean = np.asarray([0.5, 0.5, 0.5], dtype=np.float32)\n",
+    "    std = np.asarray([0.5, 0.5, 0.5], dtype=np.float32)\n",
+    "\n",
+    "    mean = mean[:, None, None]\n",
+    "    std = std[:, None, None]\n",
+    "\n",
+    "    normalized_image = (image - mean) / (std + 1e-8)\n",
+    "\n",
+    "    label = None\n",
+    "    if \"label\" in data:\n",
+    "        label = np.asarray(data[\"label\"], dtype=np.int64)\n",
+    "\n",
+    "    return (normalized_image, label)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1265691e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = h.model()\n",
+    "model.prepare_inputs = prepare_inputs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "69a6bcf0",
+   "metadata": {},
+   "source": [
+    "With the model configured, we kick off training. Hyrax handles the training loop, validation, and result logging automatically."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f58f025d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = h.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5793b02d",
+   "metadata": {},
+   "source": [
+    "## Train VGG11\n",
+    "\n",
+    "Now we switch to a locally-defined `VGG11` model. This is the key demonstration of using an **externally defined model** with Hyrax — the model is declared in `external_hyrax_example.models.vgg11` and registered with Hyrax via the `@hyrax_model` decorator, so we can reference it by its fully-qualified class path.\n",
+    "\n",
+    "We reuse the same `prepare_inputs` override from easier comparison of the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6116906c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h.set_config(\"model.name\", \"external_hyrax_example.models.vgg11.VGG11\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1797a069",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = h.model()\n",
+    "model.prepare_inputs = prepare_inputs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d163c8c5",
+   "metadata": {},
+   "source": [
+    "Train VGG11 using the same data request as before."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7f4e3d40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = h.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5bfb204c",
+   "metadata": {},
+   "source": [
+    "## Results\n",
+    "\n",
+    "Below is a comparison of training loss between the two models over the same number of epochs. VGG11 is a significantly deeper network and converges to a lower loss on this dataset.\n",
+    "\n",
+    "![loss_values](../_static/HyraxCNN_vs_VGG11.png)\n",
+    "\n",
+    "*Orange = HyraxCNN, Green = VGG11*"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "external-hyrax-example",
+   "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.13.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/pre_executed/model_usage_example.ipynb b/docs/pre_executed/model_usage_example.ipynb
index 9dd1cdf..45ef0cc 100644
--- a/docs/pre_executed/model_usage_example.ipynb
+++ b/docs/pre_executed/model_usage_example.ipynb
@@ -5,9 +5,14 @@
    "id": "51c98c81",
    "metadata": {},
    "source": [
-    "# Model Usage Example\n",
+    "# External Model Usage Example\n",
     "\n",
-    "This notebook demonstrates the use of a model defined outside of the main Hyrax package."
+    "This notebook demonstrates how to use a model class **defined outside of the Hyrax package** within Hyrax's training and inference pipeline. It covers:\n",
+    "\n",
+    "- Registering an external model (`VGG11`) with Hyrax via the `@hyrax_model` decorator\n",
+    "- Overriding default model configuration parameters at runtime\n",
+    "- Training the external model using Hyrax's built-in CIFAR-10 dataset\n",
+    "- Running inference and evaluating classification performance with a confusion matrix"
    ]
   },
   {
@@ -27,25 +32,19 @@
    "id": "d0bcaf48",
    "metadata": {},
    "source": [
-    "We'll update the configuration to use the VGG11 model defined in this package.\n",
-    "After specifying the model, we'll update one of the model parameters, enabling batch normalization."
+    "## Configure the Model\n",
+    "\n",
+    "To use an externally defined model, set `model.name` to the fully-qualified class path of your model. Hyrax will import and instantiate it automatically — the only requirement is that the class is decorated with `@hyrax_model`.\n",
+    "\n",
+    "Here we also override one of the model's defaults: `batch_norm` is `False` by default in the config, and we enable it here to demonstrate that individual model parameters can be tuned at runtime."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "1299672b",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2026-03-17 12:48:47,602 hyrax.config_utils:INFO] Merging external default config from /home/drew/code/external_hyrax_example/src/external_hyrax_example/default_config.toml\n",
-      "[2026-03-17 12:48:47,612 hyrax.config_utils:INFO] Merging external default config from /home/drew/code/external_hyrax_example/src/external_hyrax_example/default_config.toml\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "h.set_config(\"model.name\", \"external_hyrax_example.models.vgg11.VGG11\")\n",
     "h.set_config(\"external_hyrax_example.VGG11.batch_norm\", True)"
@@ -56,24 +55,17 @@
    "id": "084b5410",
    "metadata": {},
    "source": [
-    "We need to specify the data we're using too, we'll use the Hyrax Cifar dataset here."
+    "## Configure the Training Data\n",
+    "\n",
+    "We'll use `HyraxCifarDataset`, a built-in Hyrax dataset that wraps the CIFAR-10 benchmark. Setting `split_fraction: 1.0` means the full training split (50k images) is used for training with no held-out validation set."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "c0b987f8",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2026-03-17 12:48:47,639 hyrax.config_utils:INFO] Merging external default config from /home/drew/code/external_hyrax_example/src/external_hyrax_example/default_config.toml\n",
-      "[2026-03-17 12:48:47,646 hyrax.config_utils:WARNING] Runtime config contains key or section 'data_request' which has no default defined. All configuration keys and sections must be defined in /home/drew/code/hyrax/src/hyrax/hyrax_default_config.toml\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "data_request = {\n",
     "    \"train\": {\n",
@@ -89,6 +81,14 @@
     "h.set_config(\"data_request\", data_request)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "eb92acf6",
+   "metadata": {},
+   "source": [
+    "Train the model. Hyrax handles the full training loop, including batching, loss computation, and result logging."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -99,21 +99,22 @@
     "model = h.train()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "33229c5e",
+   "metadata": {},
+   "source": [
+    "## Run Inference\n",
+    "\n",
+    "Now we configure Hyrax for inference on the CIFAR-10 test set. We set `use_training_data: False` to tell the dataset to load the held-out test split (10k images). Note that `fields` no longer includes `\"label\"` — we're only requesting images since labels aren't needed during inference."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "3baeb85a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2026-03-17 12:52:14,974 hyrax.config_utils:INFO] Merging external default config from /home/drew/code/external_hyrax_example/src/external_hyrax_example/default_config.toml\n",
-      "[2026-03-17 12:52:14,981 hyrax.config_utils:WARNING] Runtime config contains key or section 'infer' which has no default defined. All configuration keys and sections must be defined in /home/drew/code/hyrax/src/hyrax/hyrax_default_config.toml\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "data_request = {\n",
     "    \"infer\": {\n",
@@ -123,7 +124,9 @@
     "            \"fields\": [\"image\"],\n",
     "            \"primary_id_field\": \"object_id\",\n",
     "            \"dataset_config\": {\n",
-    "                \"use_training_data\": False,\n",
+    "                \"HyraxCifarDataset\": {\n",
+    "                    \"use_training_data\": False,\n",
+    "                },\n",
     "            },\n",
     "        },\n",
     "    },\n",
@@ -146,16 +149,14 @@
    "id": "d6477272",
    "metadata": {},
    "source": [
-    "## Evaluating the performance\n",
+    "## Evaluate Performance\n",
     "\n",
-    "Let's compare the models predictions to the actual labels from the test dataset.\n",
-    "The model's prediction is a 10 element vector where the largest value represents the highest confidence class.\n",
-    "So we'll extract the index of the max value for each prediction and save that as `predicted_classes`."
+    "Each inference result is a 10-element vector of class logits, where the index of the largest value is the model's predicted class. We extract these predicted classes from the results returned by `h.infer()`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "970c33be",
    "metadata": {},
    "outputs": [],
@@ -173,7 +174,7 @@
    "id": "d4ae8db3",
    "metadata": {},
    "source": [
-    "We'll also load the original test data to get access to the true labels."
+    "Load the CIFAR-10 test batch to retrieve the ground-truth labels for comparison."
    ]
   },
   {
@@ -181,16 +182,7 @@
    "execution_count": null,
    "id": "26cfb65b",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_87340/3458004124.py:4: VisibleDeprecationWarning: dtype(): align should be passed as Python or NumPy boolean but got `align=0`. Did you mean to pass a tuple to create a subarray type? (Deprecated NumPy 2.4)\n",
-      "  test_data = pickle.load(f_in, encoding=\"bytes\")\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import pickle\n",
     "\n",
@@ -203,12 +195,12 @@
    "id": "e53916c7",
    "metadata": {},
    "source": [
-    "Finally we'll print the overall accuracy and use scikit-learn's ``confusion_matrix`` to display a nice confusion matrix."
+    "Finally, we compute overall accuracy and display a confusion matrix using scikit-learn. The confusion matrix shows how often each true class was predicted as each other class, making it easy to spot where the model struggles."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 14,
    "id": "bd69f21d",
    "metadata": {},
    "outputs": [
@@ -217,12 +209,12 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "Accuracy for test dataset: 0.7013\n"
+      "Accuracy for test dataset: 0.737\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
diff --git a/pyproject.toml b/pyproject.toml
index d1eeb8f..168158d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,6 +19,10 @@ requires-python = ">=3.11"
 dependencies = [
     "hyrax", # The main dependency of this project
     "torch", # Used for the example model in this project
+    "numpy", # Required by example notebooks
+    "matplotlib", # Required by example notebooks
+    "scikit-learn", # Required by example notebooks (imported as sklearn)
+    "h5py"
 ]
 
 [project.urls]
@@ -32,9 +36,6 @@ dev = [
     "pytest",
     "pytest-cov", # Used to report total code coverage
     "ruff", # Used for static linting of files
-    "numpy", # Required by example notebooks
-    "matplotlib", # Required by example notebooks
-    "scikit-learn", # Required by example notebooks (imported as sklearn)
 ]
 
 [build-system]
diff --git a/src/external_hyrax_example/datasets/galaxy10_dataset.py b/src/external_hyrax_example/datasets/galaxy10_dataset.py
new file mode 100644
index 0000000..8953db6
--- /dev/null
+++ b/src/external_hyrax_example/datasets/galaxy10_dataset.py
@@ -0,0 +1,74 @@
+import logging
+from pathlib import Path
+
+import h5py
+import numpy as np
+from hyrax.datasets import HyraxDataset
+
+logger = logging.getLogger(__name__)
+
+
+class Galaxy10Dataset(HyraxDataset):
+    """Minimal dataset class for the Galaxy10 dataset. This dataset is a collection
+    of ~22k images of galaxies categorized into 10 classes. The dataset is stored
+    in an HDF5 file available here:
+    http://www.astro.utoronto.ca/~bovy/Galaxy10/Galaxy10.h5
+
+    The dataset is made available by AstroNN: https://github.com/henrysky/astroNN
+    Deep learning of multi-element abundances from high-resolution spectroscopic data [arXiv:1808.04428]
+    """
+
+    def __init__(self, config, data_location):
+        """Initialize the Galaxy10 dataset by loading images and labels from HDF5.
+
+        This initializer:
+        - Resolves and stores the root data location.
+        - Opens the ``Galaxy10.h5`` file using ``h5py`` and reads the ``images`` and
+          ``ans`` datasets into NumPy arrays.
+        - Optionally transposes images from ``(N, H, W, C)`` to ``(N, C, H, W)`` if
+          ``channels_first`` is enabled in
+          ``config["external_hyrax_example"]["galaxy10_dataset"]["channels_first"]``.
+        - Computes the width used to zero-pad object IDs for consistent display.
+        - Calls the base :class:`HyraxDataset` initializer with the provided config.
+
+        Args:
+            config: Configuration dictionary for the Hyrax dataset and experiment.
+            data_location: Path or path-like object pointing to the directory
+                containing the ``Galaxy10.h5`` file.
+        """
+        self.data_location = Path(data_location)
+
+        # Load the file and get the images and labels
+        with h5py.File(self.data_location / "Galaxy10.h5", "r") as f:
+            self.images = np.array(f["images"])
+            self.labels = np.array(f["ans"])
+
+        # The images are stored in (N, H, W, C) format, but if channels_first is
+        # True, we transpose to (N, C, H, W)
+        self.channels_first = config["external_hyrax_example"]["galaxy10_dataset"]["channels_first"]
+        if self.channels_first:
+            self.images = self.images.transpose(0, 3, 1, 2)
+
+        # used to pad object IDs with leading zeros for consistent sorting and display
+        n_id = len(self.images)
+        self.id_width = len(str(n_id))
+
+        super().__init__(config)
+
+    def __len__(self):
+        """Returns the number of samples in the dataset"""
+        return len(self.images)
+
+    def get_object_id(self, index):
+        """Returns the object ID for the sample at the specified index.
+        Since this dataset does not have object IDs, we return the index as a string."""
+        return f"{index:0{self.id_width}d}"
+
+    def get_image(self, index):
+        """Returns the image at the specified index"""
+        # return (self.images[index].transpose(2, 0, 1) / 255.0).astype(np.float32)
+        return (self.images[index] / 255.0).astype(np.float32)
+
+    def get_label(self, index):
+        """Returns the label at the specified index"""
+        return self.labels[index]
diff --git a/src/external_hyrax_example/default_config.toml b/src/external_hyrax_example/default_config.toml
index 1986bf9..9f8bbcf 100644
--- a/src/external_hyrax_example/default_config.toml
+++ b/src/external_hyrax_example/default_config.toml
@@ -5,5 +5,14 @@ dropout = 0.5
 num_classes = 10
 batch_norm = true
 
-# The libpath that would be used for runtime config
+# libpath to specify in runtime config when using the vgg11 model
 # name = "external_hyrax_example.models.vgg11.VGG11"
+
+
+[external_hyrax_example.galaxy10_dataset]
+# When false, the images will be in (N, H, W, C) format.
+# When true, the images will be transposed to (N, C, H, W) format.
+channels_first = false
+
+# libpath to specify in runtime config when using the galaxy10 dataset
+# name = "external_hyrax_example.datasets.galaxy10_dataset.Galaxy10Dataset"
diff --git a/src/external_hyrax_example/models/vgg11.py b/src/external_hyrax_example/models/vgg11.py
index 3f341bc..1086bf4 100644
--- a/src/external_hyrax_example/models/vgg11.py
+++ b/src/external_hyrax_example/models/vgg11.py
@@ -24,10 +24,12 @@ def __init__(self, config, data_sample=None):
                 "VGG11 expected 'data_sample' to be provided at construction time "
                 "so that input channel dimensions can be inferred, but received None."
             )
+
+        # This model expects that the first element of the data sample is a batch of images.
         image_sample = data_sample[0]
-        self.in_channels, width, height = image_sample.shape
-        self.config = config
+        batch_size, self.in_channels, width, height = image_sample.shape
 
+        self.config = config
         dropout = self.config["external_hyrax_example"]["VGG11"]["dropout"]
         num_classes = self.config["external_hyrax_example"]["VGG11"]["num_classes"]
         batch_norm = self.config["external_hyrax_example"]["VGG11"]["batch_norm"]
@@ -99,11 +101,18 @@ def test_batch(self, batch):
         return {"loss": loss.item()}
 
     @staticmethod
-    def prepare_data(data_dict):
+    def prepare_inputs(data_dict):
         """Method that converts the data in dictionary into the form the model expects"""
-        image = data_dict["data"]["image"]
+
+        if "data" not in data_dict:
+            raise RuntimeError("Unable to find `data` key in data_dict")
+
+        data = data_dict["data"]
+
+        image = data["image"]
 
         label = None
         if "label" in data_dict["data"]:
             label = data_dict["data"]["label"]
+
         return (image, label)