Basic_concept_2_data_preparation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader, TensorDataset\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset\n",
    "- `torch.utils.data.Dataset` is an **abstract** class that represent a dataset\n",
    "    - Override `__len__` and `__getitem__` methods\n",
    "- `torch.utils.data.DataLoader` wraps a dataset and provides access to the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Customer dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyData(Dataset):\n",
    "    def __init__(self, input_data):\n",
    "        self.data=input_data\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        return self.data[index], index, index ** 2\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total batches:  3\n",
      "Example\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('f', 'c', 'a'), tensor([5, 2, 0]), tensor([25,  4,  0])]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_dict = {0:'a', 1:'b', 2:'c', 3:'d', 4:'e', 5:'f', 6:'g', 7:'h'}\n",
    "train_set = MyData(input_dict)\n",
    "train_loader = DataLoader(dataset=train_set, batch_size=3, shuffle=True)\n",
    "print('Total batches: ', len(train_loader))\n",
    "print('Example')\n",
    "next(iter(train_loader))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/7 [00:00<?, ?it/s]\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      "100%|██████████| 3/3 [00:00<00:00, 353.53it/s]\u001b[A\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      "100%|██████████| 3/3 [00:00<00:00, 229.67it/s]\u001b[A\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      "100%|██████████| 3/3 [00:00<00:00, 683.97it/s]\u001b[A\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      " 57%|█████▋    | 4/7 [00:00<00:00, 35.87it/s]]\u001b[A\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      "100%|██████████| 3/3 [00:00<00:00, 324.10it/s]\u001b[A\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      "100%|██████████| 3/3 [00:00<00:00, 394.54it/s]\u001b[A\n",
      "  0%|          | 0/3 [00:00<?, ?it/s]\u001b[A\n",
      "100%|██████████| 3/3 [00:00<00:00, 348.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  0\n",
      "----------\n",
      "('a', 'c', 'g')\n",
      "tensor([0, 2, 6])\n",
      "tensor([ 0,  4, 36])\n",
      "----------\n",
      "('e', 'b', 'd')\n",
      "tensor([4, 1, 3])\n",
      "tensor([16,  1,  9])\n",
      "----------\n",
      "('f', 'h')\n",
      "tensor([5, 7])\n",
      "tensor([25, 49])\n",
      "Epoch:  1\n",
      "----------\n",
      "('h', 'g', 'c')\n",
      "tensor([7, 6, 2])\n",
      "tensor([49, 36,  4])\n",
      "----------\n",
      "('b', 'e', 'd')\n",
      "tensor([1, 4, 3])\n",
      "tensor([ 1, 16,  9])\n",
      "----------\n",
      "('f', 'a')\n",
      "tensor([5, 0])\n",
      "tensor([25,  0])\n",
      "Epoch:  2\n",
      "----------\n",
      "('a', 'c', 'b')\n",
      "tensor([0, 2, 1])\n",
      "tensor([0, 4, 1])\n",
      "----------\n",
      "('d', 'h', 'g')\n",
      "tensor([3, 7, 6])\n",
      "tensor([ 9, 49, 36])\n",
      "----------\n",
      "('e', 'f')\n",
      "tensor([4, 5])\n",
      "tensor([16, 25])\n",
      "Epoch:  3\n",
      "----------\n",
      "('d', 'f', 'c')\n",
      "tensor([3, 5, 2])\n",
      "tensor([ 9, 25,  4])\n",
      "----------\n",
      "('e', 'b', 'g')\n",
      "tensor([4, 1, 6])\n",
      "tensor([16,  1, 36])\n",
      "----------\n",
      "('h', 'a')\n",
      "tensor([7, 0])\n",
      "tensor([49,  0])\n",
      "Epoch:  4\n",
      "----------\n",
      "('d', 'c', 'g')\n",
      "tensor([3, 2, 6])\n",
      "tensor([ 9,  4, 36])\n",
      "----------\n",
      "('f', 'e', 'a')\n",
      "tensor([5, 4, 0])\n",
      "tensor([25, 16,  0])\n",
      "----------\n",
      "('h', 'b')\n",
      "tensor([7, 1])\n",
      "tensor([49,  1])\n",
      "Epoch:  5\n",
      "----------\n",
      "('a', 'g', 'b')\n",
      "tensor([0, 6, 1])\n",
      "tensor([ 0, 36,  1])\n",
      "----------\n",
      "('d', 'h', 'e')\n",
      "tensor([3, 7, 4])\n",
      "tensor([ 9, 49, 16])\n",
      "----------\n",
      "('c', 'f')\n",
      "tensor([2, 5])\n",
      "tensor([ 4, 25])\n",
      "Epoch:  6\n",
      "----------\n",
      "('f', 'e', 'c')\n",
      "tensor([5, 4, 2])\n",
      "tensor([25, 16,  4])\n",
      "----------\n",
      "('a', 'g', 'h')\n",
      "tensor([0, 6, 7])\n",
      "tensor([ 0, 36, 49])\n",
      "----------\n",
      "('b', 'd')\n",
      "tensor([1, 3])\n",
      "tensor([1, 9])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7/7 [00:00<00:00, 42.20it/s]\n"
     ]
    }
   ],
   "source": [
    "for epoch in tqdm(range(7)):\n",
    "    print('Epoch: ', str(epoch))\n",
    "    for batch_x, batch_y, batch_pos in tqdm(train_loader):\n",
    "        print('-'*10)\n",
    "        print(batch_x)\n",
    "        print(batch_y)\n",
    "        print(batch_pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorDataset\n",
    "- `torch.utils.data.TensorDataset` wraps tensors (i.e., features, labels)\n",
    "- Use it as input to DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 10]) torch.Size([2]) torch.Size([2, 5]) torch.Size([2, 7])\n",
      "torch.Size([2, 10]) torch.Size([2]) torch.Size([2, 5]) torch.Size([2, 7])\n",
      "torch.Size([2, 10]) torch.Size([2]) torch.Size([2, 5]) torch.Size([2, 7])\n",
      "torch.Size([2, 10]) torch.Size([2]) torch.Size([2, 5]) torch.Size([2, 7])\n",
      "torch.Size([2, 10]) torch.Size([2]) torch.Size([2, 5]) torch.Size([2, 7])\n"
     ]
    }
   ],
   "source": [
    "# from https://discuss.pytorch.org/t/make-a-tensordataset-and-dataloader-with-multiple-inputs-parameters/26605/2\n",
    "nb_samples = 10\n",
    "\n",
    "# torch.randn returns a tensor filled with random numbers from a standard normal distribution\n",
    "features = torch.randn(nb_samples, 10)\n",
    "# tensor with size 1, elements ranges between [0, 10)\n",
    "labels = torch.empty(nb_samples, dtype=torch.long).random_(10)\n",
    "adjacency = torch.randn(nb_samples, 5)\n",
    "laplacian = torch.randn(nb_samples, 7)\n",
    "\n",
    "dataset = TensorDataset(features, labels, adjacency, laplacian)\n",
    "loader = DataLoader(\n",
    "    dataset,\n",
    "    batch_size=2\n",
    ")\n",
    "\n",
    "for batch_idx, (x, y, a, l) in enumerate(loader):\n",
    "    print(x.shape, y.shape, a.shape, l.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}