finishHEADmain

1 files changed, 1271 insertions, 0 deletions

diff --git a/Fundamentals_of_Deep_Learning/04a_asl_augmentation.ipynb b/Fundamentals_of_Deep_Learning/04a_asl_augmentation.ipynb
new file mode 100644
index 0000000..d752fff
--- /dev/null
+++ b/Fundamentals_of_Deep_Learning/04a_asl_augmentation.ipynb
@@ -0,0 +1,1271 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "J1AHrcF83Y-g"
+   },
+   "source": [
+    "<center><a href=\"https://www.nvidia.com/dli\"> <img src=\"images/DLI_Header.png\" alt=\"Header\" style=\"width: 400px;\"/> </a></center>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bBNeKAyF3Y-h"
+   },
+   "source": [
+    "# 4a. Data Augmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HTHY1Otu3Y-h"
+   },
+   "source": [
+    "So far, we've selected a model architecture that vastly improves the model's performance, as it is designed to recognize important features in the images. The validation accuracy is still lagging behind the training accuracy, which is a sign of overfitting: the model is getting confused by things it has not seen before when it tests against the validation dataset.\n",
+    "\n",
+    "In order to teach our model to be more robust when looking at new data, we're going to programmatically increase the size and variance in our dataset. This is known as [*data augmentation*](https://link.springer.com/article/10.1186/s40537-019-0197-0), a useful technique for many deep learning applications.\n",
+    "\n",
+    "The increase in size gives the model more images to learn from while training. The increase in variance helps the model ignore unimportant features and select only the features that are truly important in classification, allowing it to generalize better."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "k01AskqI3Y-h"
+   },
+   "source": [
+    "## 4a.1 Objectives"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YCFOyxKS3Y-h"
+   },
+   "source": [
+    "* Augment the ASL dataset\n",
+    "* Use the augmented data to train an improved model\n",
+    "* Save the well-trained model to disk for use in deployment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 6560,
+     "status": "ok",
+     "timestamp": 1715241340700,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "ocl26UO63Y-i",
+    "outputId": "b097ecfc-e330-4c6e-d386-4b2b7cbb55bb"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch.nn as nn\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "from torch.optim import Adam\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torchvision.transforms.v2 as transforms\n",
+    "import torchvision.transforms.functional as F\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import utils\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "torch.cuda.is_available()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "u-FCWlRg3Y-h"
+   },
+   "source": [
+    "## 4a.2 Preparing the Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JjSagpmG3Y-i"
+   },
+   "source": [
+    "As we're in a new notebook, we will load and process our data again. To do this, execute the following cell:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 3988,
+     "status": "ok",
+     "timestamp": 1715241345056,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "jYhhD7yo2WEI"
+   },
+   "outputs": [],
+   "source": [
+    "IMG_HEIGHT = 28\n",
+    "IMG_WIDTH = 28\n",
+    "IMG_CHS = 1\n",
+    "N_CLASSES = 24\n",
+    "\n",
+    "train_df = pd.read_csv(\"data/asl_data/sign_mnist_train.csv\")\n",
+    "valid_df = pd.read_csv(\"data/asl_data/sign_mnist_valid.csv\")\n",
+    "\n",
+    "class MyDataset(Dataset):\n",
+    "    def __init__(self, base_df):\n",
+    "        x_df = base_df.copy()\n",
+    "        y_df = x_df.pop('label')\n",
+    "        x_df = x_df.values / 255  # Normalize values from 0 to 1\n",
+    "        x_df = x_df.reshape(-1, IMG_CHS, IMG_WIDTH, IMG_HEIGHT)\n",
+    "        self.xs = torch.tensor(x_df).float().to(device)\n",
+    "        self.ys = torch.tensor(y_df).to(device)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        x = self.xs[idx]\n",
+    "        y = self.ys[idx]\n",
+    "        return x, y\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.xs)\n",
+    "\n",
+    "n = 32\n",
+    "train_data = MyDataset(train_df)\n",
+    "train_loader = DataLoader(train_data, batch_size=n, shuffle=True)\n",
+    "train_N = len(train_loader.dataset)\n",
+    "\n",
+    "valid_data = MyDataset(valid_df)\n",
+    "valid_loader = DataLoader(valid_data, batch_size=n)\n",
+    "valid_N = len(valid_loader.dataset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qwsfoZkE3Y-i"
+   },
+   "source": [
+    "## 4a.3 Model Creation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ze7Tv-Aj3Y-i"
+   },
+   "source": [
+    "We will also need to create our model again. As we learned in the last lesson, convolutional neural networks use a repeated sequence of layers. Let's take advantage of this pattern to make our own [custom module](https://pytorch.org/tutorials/beginner/examples_nn/two_layer_net_module.html). We can then use this module like a layer in our [Sequential](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html) model.\n",
+    "\n",
+    "To do this, we will extend the [Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) class. Then we will define two methods:\n",
+    "* `__init__`: defines any properties we want our module to have, including our neural network layers. We will effectively be using a model within a model.\n",
+    "* `forward`: defines how we want the module to process any incoming data from the previous layer it is connected to. Since we are using a `Sequential` model, we can pass the input data into it like we are making a prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 322,
+     "status": "ok",
+     "timestamp": 1715241347583,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "_o8Y7C91Bfl8"
+   },
+   "outputs": [],
+   "source": [
+    "class MyConvBlock(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch, dropout_p):\n",
+    "        kernel_size = 3\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.model = nn.Sequential(\n",
+    "            nn.Conv2d(in_ch, out_ch, kernel_size, stride=1, padding=1),\n",
+    "            nn.BatchNorm2d(out_ch),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(dropout_p),\n",
+    "            nn.MaxPool2d(2, stride=2)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.model(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we've define our custom module, let's see it in action. The below model ia archecturially the same as in the previous lesson. Can you see the connection?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1715241351435,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "I0A_7iJvB8Kc"
+   },
+   "outputs": [],
+   "source": [
+    "flattened_img_size = 75 * 3 * 3\n",
+    "\n",
+    "# Input 1 x 28 x 28\n",
+    "base_model = nn.Sequential(\n",
+    "    MyConvBlock(IMG_CHS, 25, 0), # 25 x 14 x 14\n",
+    "    MyConvBlock(25, 50, 0.2), # 50 x 7 x 7\n",
+    "    MyConvBlock(50, 75, 0),  # 75 x 3 x 3\n",
+    "    # Flatten to Dense Layers\n",
+    "    nn.Flatten(),\n",
+    "    nn.Linear(flattened_img_size, 512),\n",
+    "    nn.Dropout(.3),\n",
+    "    nn.ReLU(),\n",
+    "    nn.Linear(512, N_CLASSES)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we print the model, not only will it now show the use of our custom module, it will also show the layers within our custom module:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 465,
+     "status": "ok",
+     "timestamp": 1715241354080,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "4THc2t0HhNcv",
+    "outputId": "e25d69a9-e51a-4a90-90df-dc69a586f54b"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "OptimizedModule(\n",
+       "  (_orig_mod): Sequential(\n",
+       "    (0): MyConvBlock(\n",
+       "      (model): Sequential(\n",
+       "        (0): Conv2d(1, 25, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        (1): BatchNorm2d(25, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (2): ReLU()\n",
+       "        (3): Dropout(p=0, inplace=False)\n",
+       "        (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): MyConvBlock(\n",
+       "      (model): Sequential(\n",
+       "        (0): Conv2d(25, 50, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        (1): BatchNorm2d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (2): ReLU()\n",
+       "        (3): Dropout(p=0.2, inplace=False)\n",
+       "        (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+       "      )\n",
+       "    )\n",
+       "    (2): MyConvBlock(\n",
+       "      (model): Sequential(\n",
+       "        (0): Conv2d(50, 75, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        (1): BatchNorm2d(75, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (2): ReLU()\n",
+       "        (3): Dropout(p=0, inplace=False)\n",
+       "        (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+       "      )\n",
+       "    )\n",
+       "    (3): Flatten(start_dim=1, end_dim=-1)\n",
+       "    (4): Linear(in_features=675, out_features=512, bias=True)\n",
+       "    (5): Dropout(p=0.3, inplace=False)\n",
+       "    (6): ReLU()\n",
+       "    (7): Linear(in_features=512, out_features=24, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "loss_function = nn.CrossEntropyLoss()\n",
+    "optimizer = Adam(base_model.parameters())\n",
+    "\n",
+    "model = torch.compile(base_model.to(device))\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Custom modules are flexible, and we can define any other methods or properties we wish to have. This makes them powerful when data scientists are trying to solve complex problems."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kjBNCzfc3Y-j"
+   },
+   "source": [
+    "## 4a.4 Data Augmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "y8HdHKtM3Y-j"
+   },
+   "source": [
+    "Before defining our training loop, it's time to set up our data augmentation.\n",
+    "\n",
+    "We've seen [TorchVision](https://pytorch.org/vision/stable/index.html)'s [Transforms](https://pytorch.org/vision/0.9/transforms.html) before, but in this lesson, we will further explore its data augmentation tools. First, let's get a sample image to test with:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 312,
+     "status": "ok",
+     "timestamp": 1715241358482,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "-LT7NvrXhYwB",
+    "outputId": "4c1c1af4-811b-46d7-fa73-594772907549"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([1, 28, 28])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "row_0 = train_df.head(1)\n",
+    "y_0 = row_0.pop('label')\n",
+    "x_0 = row_0.values / 255\n",
+    "x_0 = x_0.reshape(IMG_CHS, IMG_WIDTH, IMG_HEIGHT)\n",
+    "x_0 = torch.tensor(x_0)\n",
+    "x_0.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 447
+    },
+    "executionInfo": {
+     "elapsed": 332,
+     "status": "ok",
+     "timestamp": 1715241364072,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "XKFRYIpvkUEF",
+    "outputId": "fb3f72ab-ce59-4bfc-a54a-0a4d575e497c"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f0dd0907d90>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "image = F.to_pil_image(x_0)\n",
+    "plt.imshow(image, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    3\n",
+       "Name: label, dtype: int64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_0 # d"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4a.4.1 [RandomResizeCrop](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.RandomResizedCrop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This transform will randomly resize the input image based on `scale`, and then [crop](https://en.wikipedia.org/wiki/Cropping_(image)) it to a size we specify. In this case, we will crop it to the original image dimensions. To do this, TorchVision needs to know the [aspect ratio](https://en.wikipedia.org/wiki/Aspect_ratio_(image)) of the image it is scaling. Since our height is the same as our width, our aspect `ratio` is 1:1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 2,
+     "status": "ok",
+     "timestamp": 1715241375000,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "qWINTqKypE5J"
+   },
+   "outputs": [],
+   "source": [
+    "trans = transforms.Compose([\n",
+    "    transforms.RandomResizedCrop((IMG_WIDTH, IMG_HEIGHT), scale=(.7, 1), ratio=(1, 1)),\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try running the below cell a few times. It should be different each time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 447
+    },
+    "executionInfo": {
+     "elapsed": 507,
+     "status": "ok",
+     "timestamp": 1715241377237,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "6ZugUNuJpPG2",
+    "outputId": "52caec17-6a25-4484-c2f4-2aed78b5ffe8"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f0dbfefe1d0>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "new_x_0 = trans(x_0)\n",
+    "image = F.to_pil_image(new_x_0)\n",
+    "plt.imshow(image, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 333,
+     "status": "ok",
+     "timestamp": 1715241385987,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "8VQJ1vwKp4nJ",
+    "outputId": "63521e3a-5a63-48c8-8823-bd60d6814b64"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([1, 28, 28])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_x_0.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4a.4.2 [RandomHorizontalFlip](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.RandomHorizontalFlip)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Yrmm_inJ3Y-j"
+   },
+   "source": [
+    "We can also randomly flip our images [Horizontally](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.RandomHorizontalFlip) or [Vertically](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.RandomVerticalFlip). However, for these images, we will only flip them horizontally.\n",
+    "\n",
+    "Take a moment to think about why we would want to flip images horizontally, but not vertically. When you have an idea, reveal the text below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XCLufCeF3Y-j"
+   },
+   "source": [
+    "`# SOLUTION` Fun fact: American Sign Language can be done with either the left or right hand being dominant. However, it is unlikely to see sign language from upside down. This kind of domain-specific reasoning can help make good decisions for your own deep learning applications."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trans = transforms.Compose([\n",
+    "    transforms.RandomHorizontalFlip()\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try running the below cell a few times. Does the image flip about half the time?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f0dbfb38370>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "new_x_0 = trans(x_0)\n",
+    "image = F.to_pil_image(new_x_0)\n",
+    "plt.imshow(image, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4a.4.3 [RandomRotation](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.RandomRotation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also randomly rotate the image to add more variability. Just like with with other augmentation techniques, it's easy to accidentally go too far. With ASL, if we rotate too much, our `D`s might look like `G`s and visa versa. Because of this, let's limit it to `30` degrees."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trans = transforms.Compose([\n",
+    "    transforms.RandomRotation(10)\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we run the cell block below, some black pixels may appear. The corners or our image disappear when we rotate, and for almost every pixel we lose, we gain an empty pixel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f0dbfb9ed70>"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "new_x_0 = trans(x_0)\n",
+    "image = F.to_pil_image(new_x_0)\n",
+    "plt.imshow(image, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4a.4.3 [ColorJitter](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.ColorJitter)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `ColorJitter` transform has 4 arguments:\n",
+    "* [brightness](https://en.wikipedia.org/wiki/Brightness)\n",
+    "* [contrast](https://en.wikipedia.org/wiki/Contrast_(vision))\n",
+    "* [saturation](https://en.wikipedia.org/wiki/Colorfulness#Saturation)\n",
+    "* [hue](https://en.wikipedia.org/wiki/Hue)\n",
+    "\n",
+    "\n",
+    "The latter 2 apply to color images, so we will only use the first 2 for now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "brightness = .2  # Change to be from 0 to 1\n",
+    "contrast = .5  # Change to be from 0 to 1\n",
+    "\n",
+    "trans = transforms.Compose([\n",
+    "    transforms.ColorJitter(brightness=brightness, contrast=contrast)\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try running the below a few times, but also try changing either `brightness` or `contrast` to `1`. Get any intersting results?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f0dbfafed40>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "new_x_0 = trans(x_0)\n",
+    "image = F.to_pil_image(new_x_0)\n",
+    "plt.imshow(image, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4a.3.4 [Compose](https://pytorch.org/vision/0.9/transforms.html#torchvision.transforms.Compose)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Time to bring it all together. We can create a sequence of these random transformations with `Compose`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 1,
+     "status": "ok",
+     "timestamp": 1715241387886,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "ZkXjesFKFH_b"
+   },
+   "outputs": [],
+   "source": [
+    "random_transforms = transforms.Compose([\n",
+    "    transforms.RandomRotation(5),\n",
+    "    transforms.RandomResizedCrop((IMG_WIDTH, IMG_HEIGHT), scale=(.9, 1), ratio=(1, 1)),\n",
+    "    transforms.RandomHorizontalFlip(),\n",
+    "    transforms.ColorJitter(brightness=.2, contrast=.5)\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's test it out. With all the different combinations how many varations are there of this one image? Infinite?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 447
+    },
+    "executionInfo": {
+     "elapsed": 347,
+     "status": "ok",
+     "timestamp": 1715241391170,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "ewG_7NAgqEnf",
+    "outputId": "24142f9f-286f-42ab-9769-bfd38c9defbf"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f0dbf73cfd0>"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "new_x_0 = random_transforms(x_0)\n",
+    "image = F.to_pil_image(new_x_0)\n",
+    "plt.imshow(image, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4a.4 Training with Augmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Our training is mostly the same, but there is one line of change. Before passing our images to our model, we will apply our `random_transforms`. For conveneince, we moved `get_batch_accuracy` to a [utils](./utils.py) file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 317,
+     "status": "ok",
+     "timestamp": 1715241479297,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "IcgAmvx7rI13"
+   },
+   "outputs": [],
+   "source": [
+    "def train():\n",
+    "    loss = 0\n",
+    "    accuracy = 0\n",
+    "\n",
+    "    model.train()\n",
+    "    for x, y in train_loader:\n",
+    "        output = model(random_transforms(x))  # Updated\n",
+    "        optimizer.zero_grad()\n",
+    "        batch_loss = loss_function(output, y)\n",
+    "        batch_loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        loss += batch_loss.item()\n",
+    "        accuracy += utils.get_batch_accuracy(output, y, train_N)\n",
+    "    print('Train - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On the other hamd, validation remains the same. There are no random transformations. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 382,
+     "status": "ok",
+     "timestamp": 1715241482250,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "iXc6lnRAR4qZ"
+   },
+   "outputs": [],
+   "source": [
+    "def validate():\n",
+    "    loss = 0\n",
+    "    accuracy = 0\n",
+    "\n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        for x, y in valid_loader:\n",
+    "            output = model(x)\n",
+    "\n",
+    "            loss += loss_function(output, y).item()\n",
+    "            accuracy += utils.get_batch_accuracy(output, y, valid_N)\n",
+    "    print('Valid - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's put data augmentation to the test. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 45384,
+     "status": "ok",
+     "timestamp": 1715241529445,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "isjOJIVArTLR",
+    "outputId": "5d4b6a5f-2ad9-4276-d65e-d84b9874ec3b"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0\n",
+      "Train - Loss: 650.9624 Accuracy: 0.7533\n",
+      "Valid - Loss: 59.4185 Accuracy: 0.9087\n",
+      "Epoch: 1\n",
+      "Train - Loss: 106.4973 Accuracy: 0.9609\n",
+      "Valid - Loss: 31.0323 Accuracy: 0.9487\n",
+      "Epoch: 2\n",
+      "Train - Loss: 63.1930 Accuracy: 0.9760\n",
+      "Valid - Loss: 41.5923 Accuracy: 0.9470\n",
+      "Epoch: 3\n",
+      "Train - Loss: 44.1049 Accuracy: 0.9835\n",
+      "Valid - Loss: 15.6690 Accuracy: 0.9746\n",
+      "Epoch: 4\n",
+      "Train - Loss: 33.6553 Accuracy: 0.9868\n",
+      "Valid - Loss: 33.9834 Accuracy: 0.9564\n",
+      "Epoch: 5\n",
+      "Train - Loss: 33.5910 Accuracy: 0.9871\n",
+      "Valid - Loss: 24.5062 Accuracy: 0.9631\n",
+      "Epoch: 6\n",
+      "Train - Loss: 24.8111 Accuracy: 0.9908\n",
+      "Valid - Loss: 13.0140 Accuracy: 0.9767\n",
+      "Epoch: 7\n",
+      "Train - Loss: 26.5093 Accuracy: 0.9897\n",
+      "Valid - Loss: 13.0458 Accuracy: 0.9877\n",
+      "Epoch: 8\n",
+      "Train - Loss: 18.5320 Accuracy: 0.9929\n",
+      "Valid - Loss: 10.4866 Accuracy: 0.9837\n",
+      "Epoch: 9\n",
+      "Train - Loss: 19.0155 Accuracy: 0.9926\n",
+      "Valid - Loss: 9.3474 Accuracy: 0.9835\n",
+      "Epoch: 10\n",
+      "Train - Loss: 15.9718 Accuracy: 0.9939\n",
+      "Valid - Loss: 11.1407 Accuracy: 0.9833\n",
+      "Epoch: 11\n",
+      "Train - Loss: 19.1639 Accuracy: 0.9931\n",
+      "Valid - Loss: 20.2103 Accuracy: 0.9777\n",
+      "Epoch: 12\n",
+      "Train - Loss: 14.2363 Accuracy: 0.9949\n",
+      "Valid - Loss: 15.1397 Accuracy: 0.9799\n",
+      "Epoch: 13\n",
+      "Train - Loss: 16.4096 Accuracy: 0.9937\n",
+      "Valid - Loss: 15.1409 Accuracy: 0.9801\n",
+      "Epoch: 14\n",
+      "Train - Loss: 16.2460 Accuracy: 0.9940\n",
+      "Valid - Loss: 31.5595 Accuracy: 0.9649\n",
+      "Epoch: 15\n",
+      "Train - Loss: 10.6065 Accuracy: 0.9958\n",
+      "Valid - Loss: 13.5437 Accuracy: 0.9796\n",
+      "Epoch: 16\n"
+     ]
+    }
+   ],
+   "source": [
+    "epochs = 20\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    print('Epoch: {}'.format(epoch))\n",
+    "    train()\n",
+    "    validate()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "h0WoN84J3Y-l"
+   },
+   "source": [
+    "## Discussion of Results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-EPTunxK3Y-l"
+   },
+   "source": [
+    "You will notice that the validation accuracy is higher, and more consistent. This means that our model is no longer overfitting in the way it was; it generalizes better, making better predictions on new data.\n",
+    "\n",
+    "The training accuracy may be lower, and that's ok. Compared to before, the model is being exposed to a much larger variety of data."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "npYY9cvA3Y-l"
+   },
+   "source": [
+    "## Saving the Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EW_TgWkN3Y-l"
+   },
+   "source": [
+    "Now that we have a well-trained model, we will want to deploy it to perform inference on new images.\n",
+    "\n",
+    "It is common, once we have a trained model that we are happy with to save it to disk. PyTorch has [multiple ways](https://pytorch.org/tutorials/beginner/saving_loading_models.html) to do this, but for now, we will use `torch.save`. We will also need to save the code for our `MyConvBlock` custom module, which we did in [utils.py](./utils.py). In the next notebook, we'll load the model and use it to read new sign language pictures.\n",
+    "\n",
+    "PyTorch cannot save a compiled model ([see this post](https://discuss.pytorch.org/t/how-to-save-load-a-model-with-torch-compile/179739)), so we will instead "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 326,
+     "status": "ok",
+     "timestamp": 1715241533765,
+     "user": {
+      "displayName": "Danielle Detering US",
+      "userId": "15432464718872067879"
+     },
+     "user_tz": 420
+    },
+    "id": "snAS8LalsMv4"
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(base_model, 'model.pth')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hfePFALr3Y-l"
+   },
+   "source": [
+    "## Summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7fo5z3M03Y-l"
+   },
+   "source": [
+    "In this section, you used TorchVision to augment a dataset. This resulted in a trained model with less overfitting and excellent validation image results."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TgDmGUB93Y-l"
+   },
+   "source": [
+    "### Clear the Memory\n",
+    "Before moving on, please execute the following cell to clear up the GPU memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "R6EXCtGr3Y-l"
+   },
+   "outputs": [],
+   "source": [
+    "import IPython\n",
+    "app = IPython.Application.instance()\n",
+    "app.kernel.do_shutdown(True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8DIV9ZNW3Y-l"
+   },
+   "source": [
+    "## Next"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "E4iefhaq3Y-l"
+   },
+   "source": [
+    "Now that you have a well-trained model saved to disk, you will, in the next section, deploy it to make predictions on not-yet-seen images.\n",
+    "\n",
+    "Please continue to the next notebook: [*Model Predictions*](04b_asl_predictions.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "j3I_B1M63Y-l"
+   },
+   "source": [
+    "<center><a href=\"https://www.nvidia.com/dli\"> <img src=\"images/DLI_Header.png\" alt=\"Header\" style=\"width: 400px;\"/> </a></center>"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}