coursera_deep_neural_network/1.3.1_simple_data_set_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/IDSNlogo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\"  />\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Simple Dataset</h1> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Objective</h2><ul><li> How to create a dataset in pytorch.</li><li> How to perform transformations on the dataset.</li></ul> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>In this lab, you will construct a basic dataset by using PyTorch and learn how to apply basic transformations to it.</p> \n",
    "<ul>\n",
    "    <li><a href=\"#Simple_Dataset\">Simple dataset</a></li>\n",
    "    <li><a href=\"#Transforms\">Transforms</a></li>\n",
    "    <li><a href=\"#Compose\">Compose</a></li>\n",
    "</ul>\n",
    "<p>Estimated Time Needed: <strong>30 min</strong></p>\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Preparation</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are the libraries we are going to use for this lab. The <code>torch.manual_seed()</code> is for forcing the random function to give the same number every time we try to recompile it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:49:28.567420Z",
     "start_time": "2021-07-08T07:49:28.088692Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7ffbb0157790>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# These are the libraries will be used for this lab.\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "torch.manual_seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Simple_Dataset\">Simple dataset</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us try to create our own dataset class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:49:36.016110Z",
     "start_time": "2021-07-08T07:49:36.010191Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define class for dataset\n",
    "\n",
    "class toy_set(Dataset):\n",
    "    \n",
    "    # Constructor with defult values \n",
    "    def __init__(self, length = 100, transform = None):\n",
    "        self.len = length\n",
    "        self.x = 2 * torch.ones(length, 2)\n",
    "        self.y = torch.ones(length, 1)\n",
    "        self.transform = transform\n",
    "     \n",
    "    # Getter\n",
    "    def __getitem__(self, index):\n",
    "        sample = self.x[index], self.y[index]\n",
    "        if self.transform:\n",
    "            sample = self.transform(sample)     \n",
    "        return sample\n",
    "    \n",
    "    # Get Length\n",
    "    def __len__(self):\n",
    "        return self.len"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us create our <code>toy_set</code> object, and find out the value on index 1 and the length of the inital dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:49:38.274679Z",
     "start_time": "2021-07-08T07:49:38.260405Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our toy_set object:  <__main__.toy_set object at 0x7ffabad6fdf0>\n",
      "Value on index 0 of our toy_set object:  (tensor([2., 2.]), tensor([1.]))\n",
      "Our toy_set length:  100\n"
     ]
    }
   ],
   "source": [
    "# Create Dataset Object. Find out the value on index 1. Find out the length of Dataset Object.\n",
    "\n",
    "our_dataset = toy_set()\n",
    "print(\"Our toy_set object: \", our_dataset)\n",
    "print(\"Value on index 0 of our toy_set object: \", our_dataset[0])\n",
    "print(\"Our toy_set length: \", len(our_dataset))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a result, we can apply the same indexing convention as a <code>list</code>,\n",
    "and apply the fuction <code>len</code> on the <code>toy_set</code> object. We are able to customize the indexing and length method by <code>def __getitem__(self, index)</code> and <code>def __len__(self)</code>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us print out the first 3 elements and assign them to x and y:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:49:44.808736Z",
     "start_time": "2021-07-08T07:49:44.803678Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index:  0 ; x: tensor([2., 2.]) ; y: tensor([1.])\n",
      "index:  1 ; x: tensor([2., 2.]) ; y: tensor([1.])\n",
      "index:  2 ; x: tensor([2., 2.]) ; y: tensor([1.])\n"
     ]
    }
   ],
   "source": [
    "# Use loop to print out first 3 elements in dataset\n",
    "\n",
    "for i in range(3):\n",
    "    x, y=our_dataset[i]\n",
    "    print(\"index: \", i, '; x:', x, '; y:', y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataset object is an Iterable; as a result, we  apply the loop directly on the dataset object \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:49:46.762502Z",
     "start_time": "2021-07-08T07:49:46.677989Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n",
      " x: tensor([2., 2.]) y: tensor([1.])\n"
     ]
    }
   ],
   "source": [
    "for x,y in our_dataset:\n",
    "    print(' x:', x, 'y:', y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to create an <code>toy_set</code> object with length <b>50</b>. Print out the length of your object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:51:55.582602Z",
     "start_time": "2021-07-08T07:51:55.571990Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Practice: Create a new object with length 50, and print the length of object out.\n",
    "\n",
    "# Type your code here\n",
    "\n",
    "dataset_50 = toy_set(length=50)\n",
    "len(dataset_50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "my_dataset = toy_set(length = 50)\n",
    "print(\"My toy_set length: \", len(my_dataset))\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Transforms\">Transforms</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create a class for transforming the data. In this case, we will try to add 1 to x and multiply y by 2:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:52:04.615804Z",
     "start_time": "2021-07-08T07:52:04.604742Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create tranform class add_mult\n",
    "\n",
    "class add_mult(object):\n",
    "    \n",
    "    # Constructor\n",
    "    def __init__(self, addx = 1, muly = 2):\n",
    "        self.addx = addx\n",
    "        self.muly = muly\n",
    "    \n",
    "    # Executor\n",
    "    def __call__(self, sample):\n",
    "        x = sample[0]\n",
    "        y = sample[1]\n",
    "        x = x + self.addx\n",
    "        y = y * self.muly\n",
    "        sample = x, y\n",
    "        return sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, create a transform object:.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:52:07.067706Z",
     "start_time": "2021-07-08T07:52:07.061116Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create an add_mult transform object, and an toy_set object\n",
    "\n",
    "a_m = add_mult()\n",
    "data_set = toy_set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assign the outputs of the original dataset to <code>x</code> and <code>y</code>. Then, apply the transform <code>add_mult</code> to the dataset and output the values as <code>x_</code> and <code>y_</code>, respectively: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:52:09.629220Z",
     "start_time": "2021-07-08T07:52:09.588200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index:  0 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  0 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  1 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  1 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  2 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  2 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  3 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  3 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  4 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  4 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  5 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  5 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  6 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  6 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  7 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  7 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  8 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  8 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  9 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  9 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n"
     ]
    }
   ],
   "source": [
    "# Use loop to print out first 10 elements in dataset\n",
    "\n",
    "for i in range(10):\n",
    "    x, y = data_set[i]\n",
    "    print('Index: ', i, 'Original x: ', x, 'Original y: ', y)\n",
    "    x_, y_ = a_m(data_set[i])\n",
    "    print('Index: ', i, 'Transformed x_:', x_, 'Transformed y_:', y_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the result, <code>x</code> has been added by 1 and y has been multiplied by 2, as <i>[2, 2] + 1 = [3, 3]</i> and <i>[1] x 2 = [2]</i>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply the transform object every time we create a new <code>toy_set object</code>? Remember, we have the constructor in toy_set class with the parameter <code>transform = None</code>.\n",
    "When we create a new object using the constructor, we can assign the transform object to the parameter transform, as the following code demonstrates.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:52:21.211578Z",
     "start_time": "2021-07-08T07:52:21.205181Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a new data_set object with add_mult object as transform\n",
    "\n",
    "cust_data_set = toy_set(transform = a_m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This applied <code>a_m</code> object (a transform method) to every element in <code>cust_data_set</code> as initialized. Let us print out the first 10 elements in <code>cust_data_set</code> in order to see whether the <code>a_m</code> applied on <code>cust_data_set</code>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:52:22.206569Z",
     "start_time": "2021-07-08T07:52:22.165172Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index:  0 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  0 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  1 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  1 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  2 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  2 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  3 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  3 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  4 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  4 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  5 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  5 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  6 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  6 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  7 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  7 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  8 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  8 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  9 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  9 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n"
     ]
    }
   ],
   "source": [
    "# Use loop to print out first 10 elements in dataset\n",
    "\n",
    "for i in range(10):\n",
    "    x, y = data_set[i]\n",
    "    print('Index: ', i, 'Original x: ', x, 'Original y: ', y)\n",
    "    x_, y_ = cust_data_set[i]\n",
    "    print('Index: ', i, 'Transformed x_:', x_, 'Transformed y_:', y_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is the same as the previous method.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:52:55.836173Z",
     "start_time": "2021-07-08T07:52:55.828053Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index:  0 Transformed x_: tensor([40., 40.]) Transformed y_: tensor([30.])\n",
      "Index:  1 Transformed x_: tensor([40., 40.]) Transformed y_: tensor([30.])\n",
      "Index:  2 Transformed x_: tensor([40., 40.]) Transformed y_: tensor([30.])\n"
     ]
    }
   ],
   "source": [
    "# Practice: Construct your own my_add_mult transform. Apply my_add_mult on a new toy_set object. Print out the first three elements from the transformed dataset.\n",
    "\n",
    "\n",
    "# Type your code here.\n",
    "class my_add_mult(object):\n",
    "    def __init__(self, add=2, mul=10):\n",
    "        self.add = add\n",
    "        self.mul = mul\n",
    "\n",
    "    def __call__(self, sample):\n",
    "        x = sample[0]\n",
    "        y = sample[1]\n",
    "        x = x + self.add\n",
    "        y = y + self.add\n",
    "        x = x * self.mul\n",
    "        y = y * self.mul\n",
    "        sample = x, y\n",
    "        return sample\n",
    "\n",
    "\n",
    "my_dataset = toy_set(transform=my_add_mult())\n",
    "for i in range(3):\n",
    "    x_, y_ = my_dataset[i]\n",
    "    print('Index: ', i, 'Transformed x_:', x_, 'Transformed y_:', y_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!-- \n",
    "class my_add_mult(object):   \n",
    "    def __init__(self, add = 2, mul = 10):\n",
    "        self.add=add\n",
    "        self.mul=mul\n",
    "        \n",
    "    def __call__(self, sample):\n",
    "        x = sample[0]\n",
    "        y = sample[1]\n",
    "        x = x + self.add\n",
    "        y = y + self.add\n",
    "        x = x * self.mul\n",
    "        y = y * self.mul\n",
    "        sample = x, y\n",
    "        return sample\n",
    "        \n",
    "       \n",
    "my_dataset = toy_set(transform = my_add_mult())\n",
    "for i in range(3):\n",
    "    x_, y_ = my_dataset[i]\n",
    "    print('Index: ', i, 'Transformed x_:', x_, 'Transformed y_:', y_)\n",
    "    \n",
    " -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--Empty Space for separating topics-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"Compose\">Compose</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can compose multiple transforms on the dataset object. First, import <code>transforms</code> from <code>torchvision</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:04.209673Z",
     "start_time": "2021-07-08T07:53:04.156354Z"
    }
   },
   "outputs": [],
   "source": [
    "# Run the command below when you do not have torchvision installed\n",
    "# !conda install -y torchvision\n",
    "\n",
    "from torchvision import transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, create a new transform class that multiplies each of the elements by 100: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:06.568321Z",
     "start_time": "2021-07-08T07:53:06.557339Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create tranform class mult\n",
    "\n",
    "class mult(object):\n",
    "    \n",
    "    # Constructor\n",
    "    def __init__(self, mult = 100):\n",
    "        self.mult = mult\n",
    "        \n",
    "    # Executor\n",
    "    def __call__(self, sample):\n",
    "        x = sample[0]\n",
    "        y = sample[1]\n",
    "        x = x * self.mult\n",
    "        y = y * self.mult\n",
    "        sample = x, y\n",
    "        return sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us try to combine the transforms <code>add_mult</code> and <code>mult</code>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:17.996345Z",
     "start_time": "2021-07-08T07:53:17.987892Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The combination of transforms (Compose):  Compose(\n",
      "    <__main__.add_mult object at 0x7ffab9d5b6a0>\n",
      "    <__main__.mult object at 0x7ffab9d5b790>\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Combine the add_mult() and mult()\n",
    "\n",
    "data_transform = transforms.Compose([add_mult(), mult()])\n",
    "print(\"The combination of transforms (Compose): \", data_transform)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new <code>Compose</code> object will perform each transform concurrently as shown in this figure:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/DL0110EN/notebook_images%20/chapter%201/1.3.1_trasform.png\" width=\"500\" alt=\"Compose PyTorch\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:26.098945Z",
     "start_time": "2021-07-08T07:53:26.095760Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([300., 300.]), tensor([200.]))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_transform(data_set[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:27.402321Z",
     "start_time": "2021-07-08T07:53:27.387408Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Transformed x_: tensor([300., 300.]) Transformed y_: tensor([200.])\n"
     ]
    }
   ],
   "source": [
    "x,y=data_set[0]\n",
    "x_,y_=data_transform(data_set[0])\n",
    "print( 'Original x: ', x, 'Original y: ', y)\n",
    "\n",
    "print( 'Transformed x_:', x_, 'Transformed y_:', y_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can pass the new <code>Compose</code> object (The combination of methods <code>add_mult()</code> and <code>mult</code>) to the constructor for creating <code>toy_set</code> object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:30.322750Z",
     "start_time": "2021-07-08T07:53:30.320555Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a new toy_set object with compose object as transform\n",
    "\n",
    "compose_data_set = toy_set(transform = data_transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us print out the first 3 elements in different <code>toy_set</code> datasets in order to compare the output after different transforms have been applied: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:53:31.232596Z",
     "start_time": "2021-07-08T07:53:31.204226Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index:  0 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  0 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  0 Compose Transformed x_co:  tensor([300., 300.]) Compose Transformed y_co:  tensor([200.])\n",
      "Index:  1 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  1 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  1 Compose Transformed x_co:  tensor([300., 300.]) Compose Transformed y_co:  tensor([200.])\n",
      "Index:  2 Original x:  tensor([2., 2.]) Original y:  tensor([1.])\n",
      "Index:  2 Transformed x_: tensor([3., 3.]) Transformed y_: tensor([2.])\n",
      "Index:  2 Compose Transformed x_co:  tensor([300., 300.]) Compose Transformed y_co:  tensor([200.])\n"
     ]
    }
   ],
   "source": [
    "# Use loop to print out first 3 elements in dataset\n",
    "\n",
    "for i in range(3):\n",
    "    x, y = data_set[i]\n",
    "    print('Index: ', i, 'Original x: ', x, 'Original y: ', y)\n",
    "    x_, y_ = cust_data_set[i]\n",
    "    print('Index: ', i, 'Transformed x_:', x_, 'Transformed y_:', y_)\n",
    "    x_co, y_co = compose_data_set[i]\n",
    "    print('Index: ', i, 'Compose Transformed x_co: ', x_co ,'Compose Transformed y_co: ',y_co)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us see what happened on index 0. The original value of <code>x</code> is <i>[2, 2]</i>, and the original value of <code>y</code> is [1]. If we only applied <code>add_mult()</code> on the original dataset, then the <code>x</code> became <i>[3, 3]</i> and y became <i>[2]</i>. Now let us see what is the value after applied both <code>add_mult()</code> and <code>mult()</code>. The result of x is <i>[300, 300]</i> and y is <i>[200]</i>. The calculation which is equavalent to the compose is <i> x = ([2, 2] + 1) x 100 = [300, 300], y = ([1] x 2) x 100 = 200</i>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Practice</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to combine the <code>mult()</code> and <code>add_mult()</code> as <code>mult()</code> to be executed first. And apply this on a new <code>toy_set</code> dataset. Print out the first 3 elements in the transformed dataset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-08T07:57:09.420842Z",
     "start_time": "2021-07-08T07:57:09.411190Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([201., 201.]), tensor([200.]))\n",
      "(tensor([201., 201.]), tensor([200.]))\n",
      "(tensor([201., 201.]), tensor([200.]))\n"
     ]
    }
   ],
   "source": [
    "# Practice: Make a compose as mult() execute first and then add_mult(). Apply the compose on toy_set dataset. Print out the first 3 elements in the transformed dataset.\n",
    "\n",
    "# Type your code here.\n",
    "\n",
    "from torchvision.transforms import Compose\n",
    "\n",
    "\n",
    "transfo = Compose([mult(), add_mult()])\n",
    "dataset_tr = toy_set(transform=transfo)\n",
    "for i in range(3):\n",
    "    print(dataset_tr[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click <b>here</b> for the solution.\n",
    "\n",
    "<!--\n",
    "my_compose = transforms.Compose([mult(), add_mult()])\n",
    "my_transformed_dataset = toy_set(transform = my_compose)\n",
    "for i in range(3):\n",
    "    x_, y_ = my_transformed_dataset[i]\n",
    "    print('Index: ', i, 'Transformed x_:', x_, 'Transformed y_:', y_)\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://dataplatform.cloud.ibm.com/registration/stepone?context=cpdaas&apps=data_science_experience,watson_machine_learning\"><img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/Watson_Studio.png\"/></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>About the Authors:</h2> \n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\">Joseph Santarcangelo</a> has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other contributors: <a href=\"https://www.linkedin.com/in/michelleccarey/\">Michelle Carey</a>, <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change Log\n",
    "\n",
    "| Date (YYYY-MM-DD) | Version | Changed By | Change Description                                          |\n",
    "| ----------------- | ------- | ---------- | ----------------------------------------------------------- |\n",
    "| 2020-09-21        | 2.0     | Shubham    | Migrated Lab to Markdown and added to course repo in GitLab |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
   ]
  }
 ],
 "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}