diff --git a/python/aistore/pytorch/iter_dataset.py b/python/aistore/pytorch/iter_dataset.py
index 94e201d1005..0351593b256 100644
--- a/python/aistore/pytorch/iter_dataset.py
+++ b/python/aistore/pytorch/iter_dataset.py
@@ -57,5 +57,4 @@ def __iter__(self):
                 disable=not self._show_progress,
                 force_tty=False,
             ):
-                # Update each object to use WorkerRequestSession for multithreading support
                 yield obj.name, obj.get(etl_name=self._etl_name).read_all()
diff --git a/python/aistore/sdk/bucket.py b/python/aistore/sdk/bucket.py
index efb42f8bd93..4f541c81bba 100644
--- a/python/aistore/sdk/bucket.py
+++ b/python/aistore/sdk/bucket.py
@@ -760,7 +760,7 @@ def put_files(
         Args:
             path (str): Local filepath, can be relative or absolute
             prefix_filter (str, optional): Only put files with names starting with this prefix
-            pattern (str, optional): Regex pattern to filter files
+            pattern (str, optional): Shell-style wildcard pattern to filter files
             basename (bool, optional): Whether to use the file names only as object names and omit the path information
             prepend (str, optional): Optional string to use as a prefix in the object name for all objects uploaded
                 No delimiter ("/", "-", etc.) is automatically applied between the prepend value and the object name
diff --git a/python/examples/aisio-pytorch/cifar10_training_example.ipynb b/python/examples/aisio-pytorch/cifar10_training_example.ipynb
new file mode 100644
index 00000000000..eead2fb2473
--- /dev/null
+++ b/python/examples/aisio-pytorch/cifar10_training_example.ipynb
@@ -0,0 +1,666 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PyTorch: Training CIFAR-10 using the AIStore Pytorch Plugin"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We train a classifier using the CIFAR-10 Dataset ([Learning Multiple Layers of Features from Tiny Images](https://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf), Alex Krizhevsky, 2009). Note that this notebook was run on `Python 3.11.9`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install -r ../../aistore/common_requirements --quiet\n",
+    "! pip install -r ../../aistore/pytorch/dev_requirements --quiet\n",
+    "! pip install pillow torchvision"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1). Import necessary packages, define constants, and create AIS Client."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    from aistore.sdk import Client\n",
+    "    from aistore.pytorch import AISBaseIterDataset\n",
+    "    from aistore.sdk.ais_source import AISSource\n",
+    "except:\n",
+    "\n",
+    "    # Use local version of aistore if pip version is too old\n",
+    "    import sys\n",
+    "    sys.path.append(\"../../\")\n",
+    "\n",
+    "    from aistore.sdk import Client\n",
+    "    from aistore.pytorch import AISBaseIterDataset\n",
+    "    from aistore.sdk.ais_source import AISSource\n",
+    "import requests\n",
+    "import tarfile\n",
+    "from io import BytesIO\n",
+    "import pickle\n",
+    "from torch.utils.data import DataLoader\n",
+    "import torchvision.transforms as transforms\n",
+    "from torch.utils.data import DataLoader\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "\n",
+    "from itertools import islice\n",
+    "from typing import List, Union, Dict\n",
+    "from torch.utils.data import get_worker_info"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AIS_ENDPOINT = \"http://localhost:8080\"\n",
+    "AIS_PROVIDER = \"ais\"\n",
+    "BCK_NAME = \"data-bck\"\n",
+    "\n",
+    "DATASET_URL = \"https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\"\n",
+    "\n",
+    "client = Client(endpoint=AIS_ENDPOINT)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2). Load the CIFAR-10 dataset into a bucket in our AIS Cluster."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading dataset...\n",
+      "Putting files into buckets...\n",
+      "Done putting files into buckets.\n",
+      "Cleaned up downloaded dataset.\n"
+     ]
+    }
+   ],
+   "source": [
+    "bucket = client.bucket(BCK_NAME, AIS_PROVIDER)\n",
+    "try:\n",
+    "    bucket.create(exist_ok=False)\n",
+    "\n",
+    "    print(\"Downloading dataset...\")\n",
+    "    filename = \"cifar-10-python.tar.gz\"\n",
+    "\n",
+    "    headers = {\n",
+    "        \"User-Agent\": \"Mozilla/5.0\" \n",
+    "    }\n",
+    "    response = requests.get(DATASET_URL, headers=headers, stream=True)\n",
+    "    response.raise_for_status()\n",
+    "\n",
+    "    data = BytesIO(response.content)\n",
+    "\n",
+    "    members = []\n",
+    "    with tarfile.open(fileobj=data, mode=\"r:gz\") as file:\n",
+    "        members = file.getmembers()\n",
+    "\n",
+    "        print(\"Putting files into buckets...\")\n",
+    "\n",
+    "        for member in members:\n",
+    "            if member.isfile():\n",
+    "                extracted_file = file.extractfile(member)\n",
+    "                bucket.object(member.name).put_content(extracted_file.read())\n",
+    "        \n",
+    "    print(\"Done putting files into buckets.\")\n",
+    "\n",
+    "    print(\"Cleaned up downloaded dataset.\")\n",
+    "except Exception as e:\n",
+    "    print(\"Bucket already has dataset! Nothing will be done.\")\n",
+    "    bucket.create(exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3). Extend AISBaseIterDataset to easily create an Iterable-style dataset that can parse CIFAR-10 pickle files."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CIFAR10Dataset(AISBaseIterDataset):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        cifar_ais_source: AISSource,\n",
+    "        transform: transforms.Compose,\n",
+    "        prefix_map: Dict[AISSource, Union[str, List[str]]] = {}\n",
+    "    ):\n",
+    "        super().__init__(cifar_ais_source, prefix_map)\n",
+    "        self._transform = transform\n",
+    "        self._reset_iterator()\n",
+    "\n",
+    "    def __iter__(self):\n",
+    "        worker_info = get_worker_info()            \n",
+    "            \n",
+    "        if worker_info is None or worker_info.num_workers == 1:\n",
+    "            # If not using multiple workers, load directly\n",
+    "            current_iterator = self._iterator\n",
+    "        else:\n",
+    "            current_iterator = islice(self._iterator, worker_info.id, None, worker_info.num_workers)\n",
+    "\n",
+    "        # Slice iterator based on worker id as starting index (0, 1, 2, ..) and steps of total workers\n",
+    "        for obj in current_iterator:\n",
+    "            obj_file = BytesIO(obj.get().read_all())\n",
+    "\n",
+    "            cifar_dict = pickle.load(obj_file, encoding='bytes')\n",
+    "\n",
+    "            data = cifar_dict[b\"data\"]\n",
+    "            labels = cifar_dict[b\"labels\"]\n",
+    "\n",
+    "            # Ensure the data is in the correct shape\n",
+    "            assert data.shape == (10000, 3072), \"CIFAR data files each have shape (10000, 3072)\"\n",
+    "            assert len(labels) == 10000, \"CIFAR files each store 10000 labels\"\n",
+    "            \n",
+    "            # Reshape the data to (10000, 3, 32, 32)\n",
+    "            reshaped_data = data.reshape(10000, 3, 32, 32)\n",
+    "            \n",
+    "            # Transpose the data to (10000, 32, 32, 3) to match the image format (height, width, channels)\n",
+    "            reshaped_data = reshaped_data.transpose(0, 2, 3, 1)\n",
+    "            \n",
+    "            # Get list of images tensors\n",
+    "            image_tensors = [self._transform(Image.fromarray(image.astype('uint8'), 'RGB')) for image in reshaped_data]\n",
+    "\n",
+    "            yield from iter(zip(image_tensors, labels))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4). Define our transformation (Image -> Tensor and normalzing mean/stdev)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transform = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.Resize((128, 128)), # reduce this size if your training exits due to OOM or decrease batch size\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 5). Create our training and validation datasets. \n",
+    "\n",
+    "Note that we use the same bucket for both, but by using the `prefix_map` arg, we can control which AIS objects are used in each dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "Prefix map allows us to choose specific objects from the bucket to be included in the dataset.\n",
+    "The map is a dictionary mapping the AISSource (bucket) to a list of prefixes (in this case object names).\n",
+    "If prefix map is None or not specified, then all objects will be included.\n",
+    "\"\"\"\n",
+    "\n",
+    "train_dataset = CIFAR10Dataset(\n",
+    "    cifar_ais_source=bucket,\n",
+    "    prefix_map={\n",
+    "        bucket: [\n",
+    "            \"cifar-10-batches-py/data_batch_1\",\n",
+    "            \"cifar-10-batches-py/data_batch_2\",\n",
+    "            \"cifar-10-batches-py/data_batch_3\",\n",
+    "            \"cifar-10-batches-py/data_batch_4\",\n",
+    "            \"cifar-10-batches-py/data_batch_5\",\n",
+    "        ]\n",
+    "    },\n",
+    "    transform=transform\n",
+    ")\n",
+    "\n",
+    "test_dataset = CIFAR10Dataset(\n",
+    "    cifar_ais_source=bucket,\n",
+    "    prefix_map={\n",
+    "        bucket: \"cifar-10-batches-py/test_batch\"\n",
+    "    },\n",
+    "    transform=transform\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 6). Create our training and validation dataloaders and configure workers and batch size. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BATCH_SIZE = 5\n",
+    "NUM_WORKERS = 3\n",
+    "\n",
+    "training_loader = DataLoader(\n",
+    "    dataset=train_dataset,\n",
+    "    num_workers=NUM_WORKERS,\n",
+    "    batch_size = BATCH_SIZE,\n",
+    ")\n",
+    "\n",
+    "validation_loader = DataLoader(\n",
+    "    dataset=test_dataset,\n",
+    "    num_workers=NUM_WORKERS,\n",
+    "    batch_size = BATCH_SIZE,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 7). Define a multi-layer Convolutional Neural Network (CNN) to use as our model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CIFARClassifier(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(CIFARClassifier, self).__init__()\n",
+    "        \n",
+    "        # Convolutional layers with batch normalization\n",
+    "        self.conv1 = torch.nn.Conv2d(3, 32, 3, padding=1)\n",
+    "        self.bn1 = torch.nn.BatchNorm2d(32)\n",
+    "        self.conv2 = torch.nn.Conv2d(32, 64, 3, padding=1)\n",
+    "        self.bn2 = torch.nn.BatchNorm2d(64)\n",
+    "        self.conv3 = torch.nn.Conv2d(64, 128, 3, padding=1)\n",
+    "        self.bn3 = torch.nn.BatchNorm2d(128)\n",
+    "        self.conv4 = torch.nn.Conv2d(128, 256, 3, padding=1)\n",
+    "        self.bn4 = torch.nn.BatchNorm2d(256)\n",
+    "        \n",
+    "        # Pooling layer\n",
+    "        self.pool = torch.nn.MaxPool2d(2, 2)\n",
+    "        \n",
+    "        # Adaptive pooling layer to handle variable input sizes\n",
+    "        self.adaptive_pool = torch.nn.AdaptiveAvgPool2d((2, 2))\n",
+    "        \n",
+    "        # Fully connected layers\n",
+    "        self.fc1 = torch.nn.Linear(256 * 2 * 2, 512)\n",
+    "        self.fc2 = torch.nn.Linear(512, 10)\n",
+    "        \n",
+    "        # Dropout layer\n",
+    "        self.dropout = torch.nn.Dropout(0.5)\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.pool(torch.functional.F.relu(self.bn1(self.conv1(x))))\n",
+    "        x = self.pool(torch.functional.F.relu(self.bn2(self.conv2(x))))\n",
+    "        x = self.pool(torch.functional.F.relu(self.bn3(self.conv3(x))))\n",
+    "        x = self.pool(torch.functional.F.relu(self.bn4(self.conv4(x))))\n",
+    "        \n",
+    "        # Apply adaptive pooling to ensure the output size is (2, 2)\n",
+    "        x = self.adaptive_pool(x)\n",
+    "        \n",
+    "        # Flatten the image\n",
+    "        x = x.view(-1, 256 * 2 * 2)\n",
+    "        x = self.dropout(x)\n",
+    "        x = torch.functional.F.relu(self.fc1(x))\n",
+    "        x = self.dropout(x)\n",
+    "        x = self.fc2(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 8). Define additional hyperparameters, create our classifier, loss function, and optimizer, and define class names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LEARNING_RATE = 0.0001 #0.001\n",
+    "MOMENTUM = 0.9\n",
+    "EPOCH_NUM = 19\n",
+    "WEIGHT_DECAY = 0.000125\n",
+    "\n",
+    "classifier = CIFARClassifier()\n",
+    "criterion = torch.nn.CrossEntropyLoss()\n",
+    "optimizer = torch.optim.SGD(\n",
+    "    classifier.parameters(), \n",
+    "    lr=LEARNING_RATE, \n",
+    "    momentum=MOMENTUM,\n",
+    "    weight_decay=WEIGHT_DECAY,\n",
+    ")\n",
+    "\n",
+    "classes = (\n",
+    "    \"airplane\",\t\t\t\t\t\t\t\t\t\n",
+    "    \"automobile\",\t\t\t\t\t\t\t\t\t\n",
+    "    \"bird\",\t\t\t\t\t\t\t\t\n",
+    "    \"cat\",\t\t\t\t\t\t\t\t\t\n",
+    "    \"deer\",\t\t\t\t\t\t\t\t\t\n",
+    "    \"dog\",\t\t\t\t\t\t\t\t\t\n",
+    "    \"frog\",\t\t\t\t\t\t\t\t\t\t\n",
+    "    \"horse\",\t\t\t\t\t\t\t\t\t\t\n",
+    "    \"ship\",\t\t\t\t\t\t\t\t\t\n",
+    "    \"truck\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 9). Train the model by passing the data through our model and performing back prop to calculate gradients. \n",
+    "\n",
+    "Then, validate the trained model at each epoch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EPOCH 1\n",
+      "-----------\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Samples Processed: 50000, Loss: 0.04675844684243202\n",
+      "Accuracy: 44.52%\n",
+      "\n",
+      "EPOCH 2\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.04545032978057861\n",
+      "Accuracy: 57.24%\n",
+      "\n",
+      "EPOCH 3\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.04300606623291969\n",
+      "Accuracy: 65.3%\n",
+      "\n",
+      "EPOCH 4\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.0419011227786541\n",
+      "Accuracy: 69.52%\n",
+      "\n",
+      "EPOCH 5\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.039300207048654556\n",
+      "Accuracy: 72.0%\n",
+      "\n",
+      "EPOCH 6\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.03518728166818619\n",
+      "Accuracy: 73.37%\n",
+      "\n",
+      "EPOCH 7\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.03255374729633331\n",
+      "Accuracy: 74.45%\n",
+      "\n",
+      "EPOCH 8\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.03144019469618797\n",
+      "Accuracy: 75.51%\n",
+      "\n",
+      "EPOCH 9\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.025155983865261078\n",
+      "Accuracy: 75.28%\n",
+      "\n",
+      "EPOCH 10\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.020765958353877068\n",
+      "Accuracy: 74.65%\n",
+      "\n",
+      "EPOCH 11\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.019731147214770317\n",
+      "Accuracy: 74.52%\n",
+      "\n",
+      "EPOCH 12\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.017680812627077103\n",
+      "Accuracy: 76.17%\n",
+      "\n",
+      "EPOCH 13\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.015884069725871086\n",
+      "Accuracy: 76.02%\n",
+      "\n",
+      "EPOCH 14\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.0066224741749465466\n",
+      "Accuracy: 74.6%\n",
+      "\n",
+      "EPOCH 15\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.009886597283184528\n",
+      "Accuracy: 74.41%\n",
+      "\n",
+      "EPOCH 16\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.011452939361333847\n",
+      "Accuracy: 75.75%\n",
+      "\n",
+      "EPOCH 17\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.0064519476145505905\n",
+      "Accuracy: 76.68%\n",
+      "\n",
+      "EPOCH 18\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.0025990409776568413\n",
+      "Accuracy: 76.2%\n",
+      "\n",
+      "EPOCH 19\n",
+      "-----------\n",
+      "Samples Processed: 50000, Loss: 0.0025861309841275215\n",
+      "Accuracy for class airplane: 84.9%\n",
+      "Accuracy for class automobile: 92.3%\n",
+      "Accuracy for class bird: 76.4%\n",
+      "Accuracy for class cat: 55.7%\n",
+      "Accuracy for class deer: 70.3%\n",
+      "Accuracy for class dog: 74.0%\n",
+      "Accuracy for class frog: 79.0%\n",
+      "Accuracy for class horse: 76.5%\n",
+      "Accuracy for class ship: 83.6%\n",
+      "Accuracy for class truck: 75.7%\n",
+      "Accuracy: 76.84%\n",
+      "\n",
+      "-----------\n",
+      "Finished Training\n"
+     ]
+    }
+   ],
+   "source": [
+    "for epoch in range(EPOCH_NUM):  # loop over the dataset multiple times\n",
+    "\n",
+    "    print(f\"EPOCH {epoch + 1}\\n-----------\")\n",
+    "\n",
+    "    loss = 0\n",
+    "    i = 0\n",
+    "    for i, (images, labels) in enumerate(training_loader):\n",
+    "                            \n",
+    "        # zero the parameter gradients\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # forward + backward + optimize\n",
+    "        outputs = classifier(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        # print statistics\n",
+    "        loss += loss.item()\n",
+    "\n",
+    "    print(f\"Samples Processed: {(i+1) * BATCH_SIZE}, Loss: {loss / 100}\")\n",
+    "\n",
+    "    # Validation\n",
+    "    classifier.eval()\n",
+    "    predictions = {name: [0, 0] for name in classes}\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        for images, labels in validation_loader:\n",
+    "\n",
+    "            if len(labels) != BATCH_SIZE:\n",
+    "                print(len(labels))\n",
+    "            outputs = classifier(images)\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            total += len(labels)\n",
+    "\n",
+    "            if epoch == EPOCH_NUM - 1:\n",
+    "                for label, prediction in zip(labels, predicted):\n",
+    "                    if label == prediction:\n",
+    "                        predictions[classes[label]][0] += 1\n",
+    "                    predictions[classes[label]][1] += 1\n",
+    "\n",
+    "        if epoch == EPOCH_NUM - 1:\n",
+    "            for name, data in predictions.items():\n",
+    "                successes, guesses = data[0], data[1]\n",
+    "                print(f\"Accuracy for class {name}: {100 * successes / guesses}%\")\n",
+    "\n",
+    "        print(f\"Accuracy: {100 * correct / total}%\\n\")\n",
+    "\n",
+    "print(\"-----------\\nFinished Training\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### EXTRA). Visualize each class using our dataset and matplotlib."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cat ship airplane frog automobile truck dog horse deer bird "
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from torchvision.utils import make_grid\n",
+    "\n",
+    "# Same as test dataset without normalization\n",
+    "vis_dataset = CIFAR10Dataset(\n",
+    "    cifar_ais_source=bucket,\n",
+    "    prefix_map={\n",
+    "        bucket: \"cifar-10-batches-py/test_batch\"\n",
+    "    },\n",
+    "    transform=transforms.Compose([\n",
+    "        transforms.ToTensor(),\n",
+    "    ])\n",
+    ")\n",
+    "\n",
+    "matched_images = {}\n",
+    "\n",
+    "for image, label in vis_dataset: \n",
+    "    if label not in matched_images:\n",
+    "        matched_images[label] = image\n",
+    "    if len(matched_images.keys()) == len(classes):\n",
+    "        break\n",
+    "\n",
+    "# Create a grid from the images and show them\n",
+    "img_grid = make_grid([image for image in matched_images.values()])\n",
+    "plt.imshow(img_grid.permute(1, 2, 0))\n",
+    "for label in matched_images.keys():\n",
+    "    print(classes[label], end=\" \")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/examples/aisio-pytorch/multishard_dataset_example.ipynb b/python/examples/aisio-pytorch/multishard_dataset_example.ipynb
index eb59cbbb5ab..22075b7588d 100644
--- a/python/examples/aisio-pytorch/multishard_dataset_example.ipynb
+++ b/python/examples/aisio-pytorch/multishard_dataset_example.ipynb
@@ -152,7 +152,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset = AISMultiShardStream(data_sorces=[shard1, shard2])\n",
+    "dataset = AISMultiShardStream(data_sources=[shard1, shard2])\n",
     "\n",
     "for data in dataset:\n",
     "    text_content, class_content = data\n",
diff --git a/python/examples/aisio-pytorch/shard_reader_example.ipynb b/python/examples/aisio-pytorch/shard_reader_example.ipynb
index 82f8882f037..a7bcdb3c834 100644
--- a/python/examples/aisio-pytorch/shard_reader_example.ipynb
+++ b/python/examples/aisio-pytorch/shard_reader_example.ipynb
@@ -52,7 +52,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Populate the bucket with WebDataset formatted shards using the AIS CLI\"\"\"\n",
+    "### Populate the bucket with WebDataset formatted shards using the AIS CLI\n",
     "\n",
     "To only get one shard (recommended, each shard is quite big).\n",
     "```console\n",