{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["# Recitation 0.10: Datasets"],"metadata":{"id":"ECPZWgWo35ZL"}},{"cell_type":"markdown","source":["# Imports"],"metadata":{"id":"o5pxetry2lrq"}},{"cell_type":"code","source":["import os\n","import glob\n","import numpy as np\n","import pandas as pd\n","from tqdm.notebook import tqdm\n","import torch\n","from torch.utils.data import Dataset"],"metadata":{"id":"nvWzbxwsMFTD"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# We will be connecting to Kaggle through an API .. This is the easiest way to get data.\n","# !mkdir ~/.kaggle\n","\n","# with open(\"/root/.kaggle/kaggle.json\", \"w+\") as f:\n","# f.write('{\"username\": \"\", \"key\": \"\"}')\n","\n","# !chmod 600 ~/.kaggle/kaggle.json"],"metadata":{"id":"eCRNVPGunKoJ"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Introduction to Datasets"],"metadata":{"id":"0Zz7PZC-KxPr"}},{"cell_type":"markdown","source":["In this recitation, you will learn about different datasets that will be used in our class for part 2s of the homeworks."],"metadata":{"id":"vn6jWNDhLQzN"}},{"cell_type":"markdown","source":["## Numpy Dataset"],"metadata":{"id":"MZ9KUOZDLslA"}},{"cell_type":"markdown","source":["> Create a Numpy array and save it as .npy file.\n",">\n","> (In Google Colab, default working directory is /content/, and the following code will save the array to /content/tmp_array.npy"],"metadata":{"id":"FL2MEfQWNJGW"}},{"cell_type":"code","source":["tmp_array = np.ones((3,3))\n","np.save(\"tmp_array.npy\", tmp_array)"],"metadata":{"id":"vjLTmIz7LqLf"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["> Loading Numpy array from .npy file"],"metadata":{"id":"92DIjwV1NjFS"}},{"cell_type":"code","source":["x = np.load(\"tmp_array.npy\")\n","x # To print the loaded array"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"yB8ezs8tNnXy","outputId":"02070a4c-f309-40fe-beed-a7e913d3a382","executionInfo":{"status":"ok","timestamp":1702919162689,"user_tz":300,"elapsed":22,"user":{"displayName":"Quentin Auster","userId":"15884522498219677551"}}},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["array([[1., 1., 1.],\n"," [1., 1., 1.],\n"," [1., 1., 1.]])"]},"metadata":{},"execution_count":4}]},{"cell_type":"markdown","source":["\n","\n","```\n","# This is formatted as code\n","```\n","\n","## Pandas Dataset"],"metadata":{"id":"ITk_kejoMNdV"}},{"cell_type":"markdown","source":["Note: Pandas library is not usually used for datasets in our homeworks. However, you will need pandas for writing your inference results into CSV files, which will be used for Kaggle submission."],"metadata":{"id":"-650oma1MPep"}},{"cell_type":"markdown","source":["> Generating a dummy submission table (pandas DataFrame object)"],"metadata":{"id":"D--X5zpEOQHM"}},{"cell_type":"code","source":["output = pd.DataFrame()\n","# Set the column names as 'id' and 'label'\n","output['id'] = np.array(range(5))\n","output['label'] = np.array(range(10,20,2))\n","output"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":206},"id":"7hmV9ksqMOqc","outputId":"c8b5484f-b887-44af-e428-962f6ef05d67","executionInfo":{"status":"ok","timestamp":1702919167905,"user_tz":300,"elapsed":239,"user":{"displayName":"Quentin Auster","userId":"15884522498219677551"}}},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":[" id label\n","0 0 10\n","1 1 12\n","2 2 14\n","3 3 16\n","4 4 18"],"text/html":["\n","
\n","
\n","\n","\n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n","
idlabel
0010
1112
2214
3316
4418
\n","
\n","
\n","\n","
\n"," \n","\n"," \n","\n"," \n","
\n","\n","\n","
\n"," \n","\n","\n","\n"," \n","
\n","\n","
\n"," \n"," \n"," \n","
\n","\n","
\n","
\n"]},"metadata":{},"execution_count":5}]},{"cell_type":"markdown","source":["> Save the table to CSV file"],"metadata":{"id":"2PI8ohWGOfjr"}},{"cell_type":"code","source":["output.to_csv(\"submission.csv\", index = False)"],"metadata":{"id":"LxpE0vFFOb7-"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["> Load CSV file"],"metadata":{"id":"Tr8Lv9C8Ol58"}},{"cell_type":"code","source":["output_read = pd.read_csv(\"submission.csv\")\n","output.head() # Printing the loaded table, .head() method extracts the first N(usually five) rows of the table."],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":206},"id":"nBWKuiqIOli9","outputId":"fd35ba54-e9f5-4712-da41-fdcd7ae83e1a","executionInfo":{"status":"ok","timestamp":1702919174518,"user_tz":300,"elapsed":299,"user":{"displayName":"Quentin Auster","userId":"15884522498219677551"}}},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":[" id label\n","0 0 10\n","1 1 12\n","2 2 14\n","3 3 16\n","4 4 18"],"text/html":["\n","
\n","
\n","\n","\n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n","
idlabel
0010
1112
2214
3316
4418
\n","
\n","
\n","\n","
\n"," \n","\n"," \n","\n"," \n","
\n","\n","\n","
\n"," \n","\n","\n","\n"," \n","
\n","\n","
\n","
\n"]},"metadata":{},"execution_count":7}]},{"cell_type":"markdown","source":["## Tensor Data Types\n","PyTorch adopts the\n","default 64-bit integer data type from Python. We can access the data type of a tensor via the .dtype\n","attribute of a tensor:\n"],"metadata":{"id":"l6Yg3zoig6zG"}},{"cell_type":"code","source":["tensor1d = torch.tensor([1, 2, 3])\n","print(tensor1d.dtype)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"-o6HPq5XhZaf","executionInfo":{"status":"ok","timestamp":1735108496909,"user_tz":300,"elapsed":137,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"cc7780c8-edd7-4a55-b53b-113ffb174d92"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["torch.int64\n"]}]},{"cell_type":"markdown","source":["If we create tensors from Python floats, PyTorch creates tensors with a 32-bit precision by default,\n","as we can see below:"],"metadata":{"id":"8ZpcoOpDhriP"}},{"cell_type":"code","source":["floatvec = torch.tensor([1.0, 2.0, 3.0])\n","print(floatvec.dtype)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Y8BANZxNhvTY","executionInfo":{"status":"ok","timestamp":1735108530615,"user_tz":300,"elapsed":131,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"fb2a2e2e-c0d5-44a5-ebc8-459c985a99b4"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["torch.float32\n"]}]},{"cell_type":"markdown","source":["This choice is primarily due to the balance between precision and computational efficiency. A 32-bit\n","floating point number offers sufficient precision for most deep learning tasks, while consuming less\n","memory and computational resources than a 64-bit floating point number. Moreover, GPU\n","architectures are optimized for 32-bit computations, and using this data type can significantly speed\n","up model training and inference."],"metadata":{"id":"VMN_bn_ph2wl"}},{"cell_type":"markdown","source":["\n","\n","> Common PyTorch Tensor operations\n","\n","Comprehensive coverage of all the different PyTorch tensor operations and commands is outside\n","the scope of this book. However, we will briefly describe relevant operations as we introduce them\n","throughout the book.\n"],"metadata":{"id":"U-BguwSjh5p3"}},{"cell_type":"code","source":["tensor2d = torch.tensor([[1, 2, 3], [4, 5, 6]])\n","print(tensor2d)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"j72tbpywiU2T","executionInfo":{"status":"ok","timestamp":1735108684224,"user_tz":300,"elapsed":109,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"335d96e4-cf4e-4bc1-9120-bc9f2c828a9c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["tensor([[1, 2, 3],\n"," [4, 5, 6]])\n"]}]},{"cell_type":"markdown","source":["In addition, the .shape attribute allows us to access the shape of a tensor:"],"metadata":{"id":"kJVsq2cIiZ4Y"}},{"cell_type":"code","source":["print(tensor2d.shape)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"_Nqe3eSZif6L","executionInfo":{"status":"ok","timestamp":1735108731465,"user_tz":300,"elapsed":148,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"01543717-8eb1-41a0-8d96-d49a3a93ae6e"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["torch.Size([2, 3])\n"]}]},{"cell_type":"markdown","source":["As you can see above, .shape returns [2, 3], which means that the tensor has 2 rows and 3 columns.\n","To reshape the tensor into a 3 by 2 tensor, we can use the .reshape method:"],"metadata":{"id":"nUCWPcMtiUkI"}},{"cell_type":"code","source":["print(tensor2d.reshape(3, 2))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"JplTv-2Aimdh","executionInfo":{"status":"ok","timestamp":1735108757595,"user_tz":300,"elapsed":147,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"87227fb4-ed3f-4fdc-8cd5-c067bb93ed68"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["tensor([[1, 2],\n"," [3, 4],\n"," [5, 6]])\n"]}]},{"cell_type":"markdown","source":["However, note that the more common command for reshaping tensors in PyTorch is .view():"],"metadata":{"id":"YSbJTTOAiseG"}},{"cell_type":"code","source":["print(tensor2d.view(3, 2))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"KffHBzDLit9-","executionInfo":{"status":"ok","timestamp":1735108789159,"user_tz":300,"elapsed":147,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"e37be574-7cdf-4d7b-f755-fa7393405da7"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["tensor([[1, 2],\n"," [3, 4],\n"," [5, 6]])\n"]}]},{"cell_type":"markdown","source":["Similar to .reshape and .view, there are several cases where PyTorch offers multiple syntax options\n","for executing the same computation. This is because PyTorch initially followed the original Lua\n","Torch syntax convention but then also added syntax to make it more similar to NumPy upon\n","popular request.\n","Next, we can use .T to transpose a tensor, which means flipping it across its diagonal. Note that\n","this is similar from reshaping a tensor as you can see based on the result below:"],"metadata":{"id":"30OkrCX-iyAI"}},{"cell_type":"code","source":["print(tensor2d.T)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"tTXDMhHeiwvE","executionInfo":{"status":"ok","timestamp":1735108831507,"user_tz":300,"elapsed":171,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"fdd0d8e0-98f4-4035-9a56-abd5162d5209"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["tensor([[1, 4],\n"," [2, 5],\n"," [3, 6]])\n"]}]},{"cell_type":"markdown","source":["Lastly, the common way to multiply two matrices in PyTorch is the .matmul method:"],"metadata":{"id":"zWDFU_Dni9V6"}},{"cell_type":"code","source":["print(tensor2d.matmul(tensor2d.T))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"8zwUzDm5i-es","executionInfo":{"status":"ok","timestamp":1735108856279,"user_tz":300,"elapsed":146,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"b1fef524-55d3-461d-d4ff-44e44f13c3af"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["tensor([[14, 32],\n"," [32, 77]])\n"]}]},{"cell_type":"markdown","source":["However, we can also adopt the @ operator, which accomplishes the same thing more compactly:"],"metadata":{"id":"vKhrfUBUjPh4"}},{"cell_type":"code","source":["print(tensor2d @ tensor2d.T)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"mWkNW0K3jQ-P","executionInfo":{"status":"ok","timestamp":1735108930295,"user_tz":300,"elapsed":130,"user":{"displayName":"Vedant Singh","userId":"07115245828541547553"}},"outputId":"9e43c377-b458-49eb-9bb1-cbabb44b5406"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["tensor([[14, 32],\n"," [32, 77]])\n"]}]},{"cell_type":"markdown","source":["For readers who'd like to browse through all the different tensor operations available in PyTorch\n","(hint: we won't need most of these), I recommend checking out the official documentation at\n","https://pytorch.org/docs/stable/tensors.html."],"metadata":{"id":"GB-yFpLLjc2_"}},{"cell_type":"markdown","source":["## Pytorch Dataset (Class)"],"metadata":{"id":"7-6khwdEO3oR"}},{"cell_type":"markdown","source":["```torch.utils.data.Dataset``` is a PyTorch interface for reading, organizing, preprocessing your input data of different formats.\n","\n","While PyTorch offers some datasets that work out of the box, you will need to implement your own PyTorch Dataset classes to adapt the dataset we provided, usually numpy files.\n","\n","In this tutorial, we will teach you how to create your custom Dataset class.\n","\n","For more information, check out PyTorch's documentation on [Datasets and Dataloaders](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html).\n","\n"],"metadata":{"id":"xVjgMWraO68E"}},{"cell_type":"markdown","source":["> Data loading pipeline for **PyTorch**"],"metadata":{"id":"ET_S9QjpQP4o"}},{"cell_type":"markdown","source":["![Dataset.img](data:image/png;base64,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)"],"metadata":{"id":"_0Xgk4fbQDOQ"}},{"cell_type":"markdown","source":["# BUILDING CUSTOM DATASETS IN PYTORCH\n","\n","## General Approach\n","\n","While it's tempting to jump right into defining a dataset, it is important to **understand your data first.** Whether you are working with audio data, image data, or data of another kind, load an example. Visualize it. See what shape the data is. Think about the process that generated this data in the first place. To the extent you can, think about whether the data is adequately representative of the problem you are trying to solve. These types of considerations are easy to skip on a homework, but they matter in the real world. Don't let PyTorch's lovely interface (which makes your life easier) allow you to forget all the complexity of the world and what we are trying to model!\n","\n","## Basic PyTorch Dataset Definition\n","\n","Now onto the nuts and bolts...\n","\n","When defining a Dataset class, **you need to define 3 functions**:\n","* `__init__`: Constructor function.\n","* `__len__`: Returns the length of the dataset. Usually, you can store the length in the constructor and simply return it here.\n","* `__getitem__`: Retrieves an individual observation.\n","\n","Additionally, you can also optionally define a custom `collate_fn` that will be passed to a Dataloader and controls how individual examples are batched.\n","\n","## Additional Design Considerations\n","\n","There are a few **design considerations**, your choices on which will depend on the situation. (No need to master these all at once, but food for thought). For instance:\n","* **Does your data fit into memory all at once? If so, you will probably want to load and preprocess all of your data in the `__init__` function rather than the `__getitem__` function**, because `__getitem__` is called every time your model requests data, meaning you want to reduce the computation time in this funcitno as much as possible. However, **if your data does not fit into memory all at once, you may have to create a \"memory-efficient\" dataset class that loads data in the `__getitem__` function.**\n","\n","* **Do you want to instantiate your dataset object using xs and ys? What about passing it a path to a root directory?** Many of the datasets we will be working with from kaggle have a directory structure and directory names that will allow you to simply point to a directory and have your constructor function do the work!\n"," * Among other helpful functions, check out the `os.listdir` function [here](https://docs.python.org/3/library/os.html).\n"," * Also check out the `glob` package [here](https://docs.python.org/3/library/glob.html), which provides helpful pattern-matching functionality for filenames.\n","\n","* **Should you have separate dataset classes for train (and validation) datasets versus test? (Hint: yes).** Why? Well, consider this: for your test data, do you have access to the ground truth information? No! So think about how your `__getitem__` function might be different.\n","\n","* When building an initial working prototype (and if you are loading all examples into memory), do you need to load all your training examples? Maybe not. **Consider allowing yourself to limit the number of examples loaded in for quicker iteration until you know your training pipeline works and can begin to train.**"],"metadata":{"id":"_Qj4bAjBQbrt"}},{"cell_type":"markdown","source":["## Example: A Basic Dataset Class\n","\n","A vanilla Dataset class is defined below. Think about how you might add some sprinkles!"],"metadata":{"id":"3jdcir4-E1I_"}},{"cell_type":"code","source":["class MyDataset(Dataset):\n","\n"," def __init__(self, xs, ys):\n","\n"," self.xs = xs\n"," self.ys = ys\n"," self.length = len(self.xs)\n","\n"," def __len__(self):\n"," return self.length\n","\n"," def __getitem__(self, idx):\n","\n"," return self.xs[idx], self.ys[idx]\n","\n","\n","class MyDatasetTest(Dataset):\n"," def __init__(self, xs):\n"," self.xs = xs\n"," self.length = len(self.xs)\n","\n"," def __len__(self):\n"," return self.length\n","\n"," def __getitem__(self,idx):\n"," return self.xs[idx]\n"],"metadata":{"id":"9XrxOvneQDBf"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["> Constructing and indexing into a MyDataset instance"],"metadata":{"id":"JAera0NkRr42"}},{"cell_type":"code","source":["######################################\n","# #\n","# Constructing a MyDataset object #\n","# #\n","######################################\n","\n","# Here we are generating our dummy samples and labels\n","xs = list(range(10))\n","ys = list(range(10,20))\n","\n","# Create an instance of MyDataset Class\n","dataset = MyDataset(xs, ys)\n","\n","# Check the length of the dataset\n","print(f\"len(dataset): {len(dataset)}\")\n","\n","######################################\n","# #\n","# Reading data from dataset object #\n","# #\n","######################################\n","\n","# The indexing operation will call __getitem__ function.\n","# In this case, the 0th items in xs and ys are returned as a tuple.\n","x, y = dataset[0]\n","print(x, y)\n","\n","# You can also pass the dataset to a loop\n","for x, y in dataset:\n"," print(x, y)\n"," break\n","\n","# You can also use the __next__ method\n","x, y = next(iter(dataset))\n","print(x, y)"],"metadata":{"id":"5FQpcWEDRgOb","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1702922749529,"user_tz":300,"elapsed":216,"user":{"displayName":"Quentin Auster","userId":"15884522498219677551"}},"outputId":"ca6dadf9-8366-4ab9-8de5-f1cb6a39fef0"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["len(dataset): 10\n","0 10\n","0 10\n","0 10\n"]}]},{"cell_type":"markdown","source":["## Exercise: Define your own PyTorch Dataset class"],"metadata":{"id":"tujAX8RATE0V"}},{"cell_type":"markdown","source":["Fill in the blanks to define a Dataset that takes in a list of numpy sample and label files."],"metadata":{"id":"0SekBkV0THIF"}},{"cell_type":"code","source":["class MyDataset(Dataset):\n"," # Constructor\n"," # x_files_paths will take in a list of numpy files, each file contains one sample\n"," # y_files_paths will take in a list of numpy files, each file contains one label\n"," def __init__(self, x_files_paths=[], y_files_paths=[]):\n"," self.x_files = x_files_paths\n"," self.y_files = y_files_paths\n","\n"," # Assume that there will be same number of x and y files, and the filename would be either \"x_{file_id}.npy\" or \"y_{file_id}.npy\"\n"," # The file_id is a unique identifier for each training sample.\n"," # How can you make sure that the x and y loaded are in the same order?\n"," # HINT: SORT!\n","\n"," self.x_files = _______\n"," self.y_files = _______\n","\n"," # Fill in the below two lines(might require more) to load the numpy data and store it into class variables\n"," self.x = _________\n"," self.y = _________\n","\n"," # Do some preprocessing to the data you loaded, be creative.\n"," _______\n","\n"," # __len__ method returns how many samples(data) your Dataset contains\n"," def __len__(self):\n"," return ___________ # Fill\n","\n"," # __getitem__ returns the item at index i\n"," def __getitem__(self, i):\n"," return ___________ # Fill"],"metadata":{"id":"Nl20fCnCTGqc"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Example: A Dataset based on Kaggle data"],"metadata":{"id":"aXuLqaATTn0T"}},{"cell_type":"markdown","source":["For most (if not all) of the homeworks, once you download data from Kaggle, you will have it in a directory similar to the following:\n","\n","```\n","competition-name\n"," ├── dev-clean\n"," ├── features\n"," └── labels\n"," ├── test-clean\n"," └── features\n"," └── train-clean\n"," ├── features\n"," └── labels\n","```\n","\n","Given this structure, you can write a Dataset class along the lines of the one below that constructs the dataset object using directory paths.\n","\n","(Since we don't actually have data, this code won't do much, but it is given as a general sketch of how you might write the class.)"],"metadata":{"id":"3koU2I1wT6ho"}},{"cell_type":"code","source":["class DirDataset(Dataset):\n","\n"," def __init__(self, root, limit=None, transforms=None, debug=False):\n","\n"," # (Optional) Store any arguments used outside constructor --------------\n"," # ...\n","\n"," # Get filepaths --------------------------------------------------------\n"," feat_dir = os.path.join(root, 'features')\n"," label_dir = os.path.join(root, 'labels')\n","\n"," if limit is None:\n"," feat_fnames = sorted(os.listdir(feat_dir))\n"," label_fnames = sorted(os.listdir(label_dir))\n"," else:\n"," feat_fnames = sorted(os.listdir(feat_dir))[:limit]\n"," label_fnames = sorted(os.listdir(label_dir))[:limit]\n","\n"," feat_paths = [os.path.join(feat_dir, fname) for fname in feat_fnames]\n"," label_paths = [os.path.join(label_dir, fname) for fname in label_fnames]\n","\n"," # Set length -----------------------------------------------------------\n"," assert len(feat_paths) == len(label_paths)\n"," self.length = len(feat_paths)\n","\n"," # Loop through filepaths, load, preprocess, and store ------------------\n"," self.feats, self.labels = [], []\n"," for feat_path, label_path in tqdm(zip(feat_paths, label_paths)):\n","\n"," # Load files\n"," feat = np.load(feat_path)\n"," label = np.load(label_path)\n","\n"," # (Optional) Preprocessing\n"," # ...\n","\n"," # Append to list\n"," self.feats.append(feat)\n"," self.labels.append(label)\n","\n"," # (Optional) Concatenate and add context\n","\n"," if debug: print('Dataset created')\n","\n","\n"," def __len__(self):\n","\n"," return self.length\n","\n"," def __getitem__(self, idx):\n","\n"," return self.feats[idx], self.labels[idx]\n","\n","\n","class DirDatasetTest(Dataset):\n","\n"," def __init__(self, root, limit=None, transforms=None, debug=False):\n"," \"\"\"\n"," Note: This is identical to the above, just without labels.\n"," \"\"\"\n","\n"," # (Optional) Store any arguments used outside constructor --------------\n"," # ...\n","\n"," # Get filepaths --------------------------------------------------------\n"," feat_dir = os.path.join(root, 'features')\n","\n"," if limit is None:\n"," feat_fnames = sorted(os.listdir(feat_dir))\n"," else:\n"," feat_fnames = sorted(os.listdir(feat_dir))[:limit]\n","\n"," feat_paths = [os.path.join(feat_dir, fname) for fname in feat_fnames]\n","\n"," # Set length -----------------------------------------------------------\n"," self.length = len(feat_paths)\n","\n"," # Loop through filepaths, load, preprocess, and store ------------------\n"," self.feats = []\n"," for feat_path in tqdm(feat_paths):\n","\n"," # Load files\n"," feat = np.load(feat_path)\n","\n"," # (Optional) Preprocessing\n"," # ...\n","\n"," # Append to list\n"," self.feats.append(feat)\n","\n"," # (Optional) Concatenate and add context\n","\n"," if debug: print('Dataset created')\n","\n","\n"," def __len__(self):\n","\n"," return self.length\n","\n"," def __getitem__(self, idx):\n","\n"," return self.feats[idx]\n"],"metadata":{"id":"e0zJ0H17T5bd"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["train_dataset = DirDataset(os.path.join('competition-name', 'train-clean'))\n","valid_dataset = DirDataset(os.path.join('competition-name', 'dev-clean'))\n","test_dataset = DirDatasetTest(os.path.join('competition-name', 'test-clean'))"],"metadata":{"id":"0FdClYTDTv1y"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Food for thought: Outside of the world of Kaggle, which very nicely splits train, dev, and test sets for you, how might you make these splits yourself?"],"metadata":{"id":"lRW6xUszXGWh"}}]}