{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# unit 4.3 - Data loaders\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/culurciello/deep-learning-course-source/blob/main/source/lectures/43-dataloaders.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Data loaders from PyTorch](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html) are a very useful tool to load data in batches and shuffle it. This is very useful when training neural networks.\n",
    "\n",
    "Most of a data scientist time is used on data preparation. Data scientists can spend 90-95% of their time on data preparation, so it is important to have a good data loader that can handle the data in a way that is easy to use and efficient.\n",
    "\n",
    "Here we create a custom dataset loader for a folder of images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports:\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Transforms in PyTorch](https://pytorch.org/vision/0.9/transforms.html) are very useful to preprocess data. Here we use `transforms.Compose` to chain together a series of transforms. We use `transforms.Resize` to resize the image to a fixed size, `transforms.Normalize` to set the value of mean and std for each input channel, and `transforms.ToTensor` to convert the image to a tensor. There are many other transforms available in PyTorch, such as `transforms.CenterCrop` to crop the image to a fixed size, and more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose([\n",
    "    transforms.Resize((32,32)),\n",
    "    transforms.ToTensor(),\n",
    "    # transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # mean and std for 3 channels - should be 0 and 1, but here we use this to visualize the images in full color\n",
    "    transforms.Normalize((0.0, 0.0, 0.0), (1.0, 1.0, 1.0))\n",
    "])\n",
    "\n",
    "batch_size = 3\n",
    "trainset = torchvision.datasets.ImageFolder(root='./data/my_data/train', \n",
    "                                            transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "classes = ('cat1', 'cat2', 'cat3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we plot a few examples of the images in the dataset. This is useful to check if the data loader is working correctly. We always need to visualize what is the input for the neural network.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat1  cat3  cat1 \n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# functions to show an image\n",
    "def imshow(img):\n",
    "    img = img / 2 + 0.5     # un-normalize\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = next(dataiter)\n",
    "# print(images[0].shape, images[0].mean(), images[0].std())\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Issues\n",
    "\n",
    "Sometimes, especially when dealing with images, the input data size can be very large. In this case, we can use `transforms.CenterCrop` to crop the image to a fixed size, and `transforms.RandomCrop` to crop the image to a random size. This is useful to reduce the input size and speed up training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat2  cat3  cat1 \n"
     ]
    }
   ],
   "source": [
    "# same example as above but with randomcrop\n",
    "transform = transforms.Compose([\n",
    "    # transforms.Resize((32,32)),\n",
    "    transforms.RandomCrop(32, padding=4),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "])\n",
    "\n",
    "batch_size = 3\n",
    "trainset = torchvision.datasets.ImageFolder(root='./data/my_data/train', \n",
    "                                            transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "classes = ('cat1', 'cat2', 'cat3')\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = next(dataiter)\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see this may or may not work, because we may be getting parts of the images that have no content of interest.\n",
    "\n",
    "Here we try to load them all in original size, but it will fail because the data loader wants all images to be of the same size!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "Caught RuntimeError in DataLoader worker process 0.\nOriginal Traceback (most recent call last):\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/worker.py\", line 309, in _worker_loop\n    data = fetcher.fetch(index)  # type: ignore[possibly-undefined]\n           ^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/fetch.py\", line 55, in fetch\n    return self.collate_fn(data)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 317, in default_collate\n    return collate(batch, collate_fn_map=default_collate_fn_map)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 174, in collate\n    return [collate(samples, collate_fn_map=collate_fn_map) for samples in transposed]  # Backwards compatibility.\n            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 142, in collate\n    return collate_fn_map[elem_type](batch, collate_fn_map=collate_fn_map)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 214, in collate_tensor_fn\n    return torch.stack(batch, 0, out=out)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nRuntimeError: stack expects each tensor to be equal size, but got [3, 154, 220] at entry 0 and [3, 132, 126] at entry 1\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[11], line 19\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[38;5;66;03m# get some random training images\u001b[39;00m\n\u001b[1;32m     18\u001b[0m dataiter \u001b[38;5;241m=\u001b[39m \u001b[38;5;28miter\u001b[39m(trainloader)\n\u001b[0;32m---> 19\u001b[0m images, labels \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdataiter\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     21\u001b[0m \u001b[38;5;66;03m# show images\u001b[39;00m\n\u001b[1;32m     22\u001b[0m imshow(torchvision\u001b[38;5;241m.\u001b[39mutils\u001b[38;5;241m.\u001b[39mmake_grid(images))\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/dataloader.py:630\u001b[0m, in \u001b[0;36m_BaseDataLoaderIter.__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    627\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sampler_iter \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    628\u001b[0m     \u001b[38;5;66;03m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[1;32m    629\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reset()  \u001b[38;5;66;03m# type: ignore[call-arg]\u001b[39;00m\n\u001b[0;32m--> 630\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_next_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    631\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_yielded \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m    632\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_dataset_kind \u001b[38;5;241m==\u001b[39m _DatasetKind\u001b[38;5;241m.\u001b[39mIterable \u001b[38;5;129;01mand\u001b[39;00m \\\n\u001b[1;32m    633\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_IterableDataset_len_called \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \\\n\u001b[1;32m    634\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_yielded \u001b[38;5;241m>\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_IterableDataset_len_called:\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/dataloader.py:1344\u001b[0m, in \u001b[0;36m_MultiProcessingDataLoaderIter._next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1342\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   1343\u001b[0m     \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_task_info[idx]\n\u001b[0;32m-> 1344\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_process_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/dataloader.py:1370\u001b[0m, in \u001b[0;36m_MultiProcessingDataLoaderIter._process_data\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m   1368\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_try_put_index()\n\u001b[1;32m   1369\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(data, ExceptionWrapper):\n\u001b[0;32m-> 1370\u001b[0m     \u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreraise\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1371\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m data\n",
      "File \u001b[0;32m/opt/homebrew/lib/python3.12/site-packages/torch/_utils.py:706\u001b[0m, in \u001b[0;36mExceptionWrapper.reraise\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    702\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m    703\u001b[0m     \u001b[38;5;66;03m# If the exception takes multiple arguments, don't try to\u001b[39;00m\n\u001b[1;32m    704\u001b[0m     \u001b[38;5;66;03m# instantiate since we don't know how to\u001b[39;00m\n\u001b[1;32m    705\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m--> 706\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exception\n",
      "\u001b[0;31mRuntimeError\u001b[0m: Caught RuntimeError in DataLoader worker process 0.\nOriginal Traceback (most recent call last):\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/worker.py\", line 309, in _worker_loop\n    data = fetcher.fetch(index)  # type: ignore[possibly-undefined]\n           ^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/fetch.py\", line 55, in fetch\n    return self.collate_fn(data)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 317, in default_collate\n    return collate(batch, collate_fn_map=default_collate_fn_map)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 174, in collate\n    return [collate(samples, collate_fn_map=collate_fn_map) for samples in transposed]  # Backwards compatibility.\n            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 142, in collate\n    return collate_fn_map[elem_type](batch, collate_fn_map=collate_fn_map)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/opt/homebrew/lib/python3.12/site-packages/torch/utils/data/_utils/collate.py\", line 214, in collate_tensor_fn\n    return torch.stack(batch, 0, out=out)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nRuntimeError: stack expects each tensor to be equal size, but got [3, 154, 220] at entry 0 and [3, 132, 126] at entry 1\n"
     ]
    }
   ],
   "source": [
    "# load one image and display it full size\n",
    "\n",
    "transform = transforms.Compose([\n",
    "    # transforms.Resize((32,32)),\n",
    "    # transforms.RandomCrop(32, padding=4),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "])\n",
    "\n",
    "batch_size = 3\n",
    "trainset = torchvision.datasets.ImageFolder(root='./data/my_data/train', \n",
    "                                            transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "classes = ('cat1', 'cat2', 'cat3')\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = next(dataiter)\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, imagine that we want to identify animal species based on their eye, then we will need to either use large resolution input images or to crop the images to the eye region. Here we will do it manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load properly cropped data:\n",
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.Resize((32,32)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "])\n",
    "\n",
    "batch_size = 3\n",
    "trainset = torchvision.datasets.ImageFolder(root='./data/my_data_crops/train', \n",
    "                                            transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "classes = ('cat1', 'cat2', 'cat3')\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = next(dataiter)\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notes\n",
    "\n",
    "There is a lot that can go wrong just here, when preparing the data for neural network training. This is why it is important to visualize the data and check if it is being loaded correctly.\n",
    "\n",
    "Always check your steps and make sure that the data is being loaded correctly. This will save you a lot of time from debugging. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.12",
   "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.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}