From 53f20d58628171934c097dff5602fe17765eae99 Mon Sep 17 00:00:00 2001 From: leshe4ka46 Date: Thu, 25 Dec 2025 21:28:30 +0300 Subject: finish --- Fundamentals_of_Deep_Learning/02_asl.ipynb | 1722 ++++++++++++++++++++++++++++ 1 file changed, 1722 insertions(+) create mode 100644 Fundamentals_of_Deep_Learning/02_asl.ipynb (limited to 'Fundamentals_of_Deep_Learning/02_asl.ipynb') diff --git a/Fundamentals_of_Deep_Learning/02_asl.ipynb b/Fundamentals_of_Deep_Learning/02_asl.ipynb new file mode 100644 index 0000000..4f8fcc7 --- /dev/null +++ b/Fundamentals_of_Deep_Learning/02_asl.ipynb @@ -0,0 +1,1722 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "RDQqqfRXTjyJ" + }, + "source": [ + "
\"Header\"
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oq7vdepBTjyK" + }, + "source": [ + "# 2. Image Classification of an American Sign Language Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2nP3rWXBTjyK" + }, + "source": [ + "In this section, we will perform the data preparation, model creation, and model training steps we observed in the last section using a different dataset: images of hands making letters in [American Sign Language](http://www.asl.gs/)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Cs1ioXE2TjyK" + }, + "source": [ + "## 2.1 Objectives" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WzY0p5NZTjyK" + }, + "source": [ + "* Prepare image data for training\n", + "* Create and compile a simple model for image classification\n", + "* Train an image classification model and observe the results" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 849, + "status": "ok", + "timestamp": 1715066695195, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "Ev0pS0GdTjyM", + "outputId": "63e4a89f-c58b-4401-e6a5-4350b5df7714" + }, + "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", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mhGii0pzTjyL" + }, + "source": [ + "## 2.2 American Sign Language Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x3IH42b2TjyL" + }, + "source": [ + "The [American Sign Language alphabet](http://www.asl.gs/) contains 26 letters. Two of those letters (j and z) require movement, so they are not included in the training dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Xtnc5S_lTjyL" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ihN8_4hfTjyL" + }, + "source": [ + "### 2.2.1 Kaggle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "winTCTjiTjyL" + }, + "source": [ + "This dataset is available from the website [Kaggle](http://www.kaggle.com), which is a fantastic place to find datasets and other deep learning resources. In addition to providing resources like datasets and \"kernels\" that are like these notebooks, Kaggle hosts competitions that you can take part in, competing with others in training highly accurate models.\n", + "\n", + "If you're looking to practice or see examples of many deep learning projects, Kaggle is a great site to visit." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xzRiOTvsTjyL" + }, + "source": [ + "## 2.3 Loading the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7OouJPWVTjyL" + }, + "source": [ + "This dataset is not available via TorchVision in the same way that MNIST is, so let's learn how to load custom data. By the end of this section we will have `x_train`, `y_train`, `x_valid`, and `y_valid` variables." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rpKiBdCsTjyL" + }, + "source": [ + "### 2.3.1 Reading in the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mRBOfwA9TjyM" + }, + "source": [ + "The sign language dataset is in [CSV](https://en.wikipedia.org/wiki/Comma-separated_values) (Comma Separated Values) format, the same data structure behind Microsoft Excel and Google Sheets. It is a grid of rows and columns with labels at the top, as seen in the [train](data/asl_data/sign_mnist_train.csv) and [valid](data/asl_data/sign_mnist_valid.csv) datasets (they may take a moment to load).\n", + "\n", + "To load and work with the data, we'll be using a library called [Pandas](https://pandas.pydata.org/), which is a highly performant tool for loading and manipulating data. We'll read the CSV files into a format called a [DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bbhLk9sVTjyM" + }, + "source": [ + "Pandas has a [read_csv](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html) method that expects a csv file, and returns a DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "JeIOe1X4TjyM" + }, + "outputs": [], + "source": [ + "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\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BuiUoPWzTjyM" + }, + "source": [ + "### 2.3.2 Exploring the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GbirW1rxTjyM" + }, + "source": [ + "Let's take a look at our data. We can use the [head](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html) method to print the first few rows of the DataFrame. Each row is an image which has a `label` column, and also, 784 values representing each pixel value in the image, just like with the MNIST dataset. Note that the labels currently are numerical values, not letters of the alphabet:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 255 + }, + "executionInfo": { + "elapsed": 8, + "status": "ok", + "timestamp": 1715064545381, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "_jEITmvETjyM", + "outputId": "5444b9eb-1948-4140-95c4-91649677766b" + }, + "outputs": [ + { + "data": { + "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", + " \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", + " \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", + " \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", + "
labelpixel1pixel2pixel3pixel4pixel5pixel6pixel7pixel8pixel9...pixel775pixel776pixel777pixel778pixel779pixel780pixel781pixel782pixel783pixel784
03107118127134139143146150153...207207207207206206206204203202
16155157156156156157156158158...691491288794163175103135149
22187188188187187186187188187...202201200199198199198195194195
32211211212212211210211210210...235234233231230226225222229163
412164167170172176179180184185...92105105108133163157163164179
\n", + "

5 rows × 785 columns

\n", + "
" + ], + "text/plain": [ + " label pixel1 pixel2 pixel3 pixel4 pixel5 pixel6 pixel7 pixel8 \\\n", + "0 3 107 118 127 134 139 143 146 150 \n", + "1 6 155 157 156 156 156 157 156 158 \n", + "2 2 187 188 188 187 187 186 187 188 \n", + "3 2 211 211 212 212 211 210 211 210 \n", + "4 12 164 167 170 172 176 179 180 184 \n", + "\n", + " pixel9 ... pixel775 pixel776 pixel777 pixel778 pixel779 pixel780 \\\n", + "0 153 ... 207 207 207 207 206 206 \n", + "1 158 ... 69 149 128 87 94 163 \n", + "2 187 ... 202 201 200 199 198 199 \n", + "3 210 ... 235 234 233 231 230 226 \n", + "4 185 ... 92 105 105 108 133 163 \n", + "\n", + " pixel781 pixel782 pixel783 pixel784 \n", + "0 206 204 203 202 \n", + "1 175 103 135 149 \n", + "2 198 195 194 195 \n", + "3 225 222 229 163 \n", + "4 157 163 164 179 \n", + "\n", + "[5 rows x 785 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9vZwdu4yTjyN" + }, + "source": [ + "### 2.3.3 Extracting the Labels" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wxRL89IvTjyN" + }, + "source": [ + "Let's store our training and validation labels in `y_train` and `y_valid` variables. We can use the [pop](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.pop.html) method to remove a column from our DataFrame and assign the removed values to a variable." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 2, + "status": "ok", + "timestamp": 1715064546558, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "EYujv09jTjyN", + "outputId": "572b986c-d128-4b25-9083-9d9607c9b680" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0 3\n", + "1 6\n", + "2 2\n", + "3 2\n", + "4 12\n", + " ..\n", + "27450 12\n", + "27451 22\n", + "27452 17\n", + "27453 16\n", + "27454 22\n", + "Name: label, Length: 27455, dtype: int64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train = train_df.pop('label')\n", + "y_valid = valid_df.pop('label')\n", + "y_train" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WQ6EtXGYTjyN" + }, + "source": [ + "### 2.3.4 Extracting the Images" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_mue0q7BTjyN" + }, + "source": [ + "Next, let's store our training and validation images in `x_train` and `x_valid` variables. Here we create those variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 2, + "status": "ok", + "timestamp": 1715064548501, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "7sP3fSkETjyN", + "outputId": "6e04f85b-fb2d-444d-fc08-28a5741c3c6f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[107, 118, 127, ..., 204, 203, 202],\n", + " [155, 157, 156, ..., 103, 135, 149],\n", + " [187, 188, 188, ..., 195, 194, 195],\n", + " ...,\n", + " [174, 174, 174, ..., 202, 200, 200],\n", + " [177, 181, 184, ..., 64, 87, 93],\n", + " [179, 180, 180, ..., 205, 209, 215]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train = train_df.values\n", + "x_valid = valid_df.values\n", + "x_train" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6s7y8MYOTjyN" + }, + "source": [ + "### 2.3.5 Summarizing the Training and Validation Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YkVK5sL_TjyN" + }, + "source": [ + "We now have 27,455 images with 784 pixels each for training..." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 270, + "status": "ok", + "timestamp": 1715064412921, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "l7liruaxTjyN", + "outputId": "9b462f1d-6306-47bf-d292-151b9847e1ad" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(27455, 784)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WKP6-UT0TjyN" + }, + "source": [ + "...as well as their corresponding labels:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 3, + "status": "ok", + "timestamp": 1715064415052, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "d4OguU-wTjyN", + "outputId": "d2030105-2f87-44ff-a13d-d530a63c46df" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(27455,)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VKuHu4V2TjyN" + }, + "source": [ + "For validation, we have 7,172 images..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 3, + "status": "ok", + "timestamp": 1715064416314, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "AFx0PRCsTjyN", + "outputId": "e25714a6-07a2-4a5f-9dcb-e197e9fee5cb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(7172, 784)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_valid.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cfEP85sSTjyN" + }, + "source": [ + "...and their corresponding labels:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 3, + "status": "ok", + "timestamp": 1715064417463, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "5UgDUqppTjyO", + "outputId": "98f60c26-9975-4da8-e108-3b6b1503721d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(7172,)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_valid.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UWrF4zYPTjyO" + }, + "source": [ + "## 2.4 Visualizing the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HJnxfcGJTjyO" + }, + "source": [ + "To visualize the images, we will again use the matplotlib library. We don't need to worry about the details of this visualization, but if interested, you can learn more about [matplotlib](https://matplotlib.org/) at a later time.\n", + "\n", + "Note that we'll have to reshape the data from its current 1D shape of 784 pixels, to a 2D shape of 28x28 pixels to make sense of the image:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 58 + }, + "executionInfo": { + "elapsed": 972, + "status": "ok", + "timestamp": 1715064554564, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "k-Fkl2mTTjyO", + "outputId": "3fe64867-d689-497c-d0b7-4a27edf8e89d" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.figure(figsize=(40,40))\n", + "\n", + "num_images = 20\n", + "for i in range(num_images):\n", + " row = x_train[i]\n", + " label = y_train[i]\n", + "\n", + " image = row.reshape(28,28)\n", + " plt.subplot(1, num_images, i+1)\n", + " plt.title(label, fontdict={'fontsize': 30})\n", + " plt.axis('off')\n", + " plt.imshow(image, cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2j5Nwh7zTjyO" + }, + "source": [ + "### 2.4.1 Normalize the Image Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xYfdAXx5TjyV" + }, + "source": [ + "As we did with the MNIST dataset, we are going to normalize the image data, meaning that their pixel values, instead of being between 0 and 255 as they are currently:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 3, + "status": "ok", + "timestamp": 1715064422916, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "zbEOSxuYTjyV", + "outputId": "d30e221e-99db-4e20-fdb6-cf67fb273225" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.min()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 2, + "status": "ok", + "timestamp": 1715064423943, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "kAERnWUcTjyV", + "outputId": "57e592d4-a36e-4f3e-f924-d157fa9680ef" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "255" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.max()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_KWYaVLTTjyV" + }, + "source": [ + "In the previous lab, we used [ToTensor](https://pytorch.org/vision/main/generated/torchvision.transforms.ToTensor.html), but we can also modify our data before turning it into a tensor." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "s3bf3TvgTjyW" + }, + "outputs": [], + "source": [ + "x_train = train_df.values / 255\n", + "x_valid = valid_df.values / 255" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4.2 Custom Datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iKQR2ouf7Q2r" + }, + "source": [ + "We can use PyTorch's [Dataset](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html) tools in order to create our own dataset. `__init__` will run once when the class is initialized. `__getitem__` returns our images and labels.\n", + "\n", + "Since our dataset is small enough, we can store it on our GPU for faster processing. In the previous lab, we sent our data to the GPU when it was drawn from each batch. Here, we will send it to the GPU in the `__init__` function." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "KeKWb8tZ6jCy" + }, + "outputs": [], + "source": [ + "class MyDataset(Dataset):\n", + " def __init__(self, x_df, y_df):\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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A custom PyTorch dataset works just like a prebuilt one. It should be passed to a [DataLoader](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html#preparing-your-data-for-training-with-dataloaders) for model training." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "XoSSM2YEAh_6" + }, + "outputs": [], + "source": [ + "BATCH_SIZE = 32\n", + "\n", + "train_data = MyDataset(x_train, y_train)\n", + "train_loader = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True)\n", + "train_N = len(train_loader.dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "cfAM1uoP1anX" + }, + "outputs": [], + "source": [ + "valid_data = MyDataset(x_valid, y_valid)\n", + "valid_loader = DataLoader(valid_data, batch_size=BATCH_SIZE)\n", + "valid_N = len(valid_loader.dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can verify the DataLoader works as expected with the code below. We'll make the DataLoader [iterable](https://docs.python.org/3/library/functions.html#iter), and then call [next](https://docs.python.org/3/library/functions.html#next) to draw the first hand from the deck." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_loader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try running the below a few times. The values should change each time." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 3, + "status": "ok", + "timestamp": 1715068148957, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "5nRQD_koZ5jm", + "outputId": "f24f27e7-2452-46a2-ca83-0710c822b9f3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[tensor([[0.6235, 0.6353, 0.6392, ..., 0.1294, 0.0667, 0.0510],\n", + " [0.2000, 0.2314, 0.2510, ..., 0.6863, 0.6941, 0.7020],\n", + " [0.8000, 0.8000, 0.8039, ..., 0.1020, 0.0941, 0.1216],\n", + " ...,\n", + " [0.6157, 0.6314, 0.6392, ..., 0.3020, 0.4353, 0.7961],\n", + " [0.6353, 0.6431, 0.6471, ..., 0.4275, 0.2196, 0.1725],\n", + " [0.3647, 0.3922, 0.4118, ..., 0.6706, 0.6627, 0.6824]],\n", + " device='cuda:0'),\n", + " tensor([ 5, 17, 7, 20, 11, 22, 7, 3, 13, 14, 14, 6, 7, 15, 6, 16, 7, 17,\n", + " 10, 14, 0, 16, 22, 7, 18, 18, 5, 23, 13, 15, 9, 20],\n", + " device='cuda:0')]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch = next(iter(train_loader))\n", + "batch" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice the batch has two values. The first is our `x`, and the second is our `y`. The first dimension of each should have `32` values, which is the `batch_size`." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([32, 784])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([32])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch[1].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KkD0MEZ1TjyX" + }, + "source": [ + "## 2.5 Build the Model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PHyHRWPdTjyX" + }, + "source": [ + "We've created our DataLoaders, now it's time to build our models." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this exercise we are going to build a sequential model. Just like last time, build a model that:\n", + "\n", + "* Has a flatten layer.\n", + "* Has a dense input layer. This layer should contain 512 neurons amd use the `relu` activation function\n", + "* Has a second dense layer with 512 neurons which uses the `relu` activation function\n", + "* Has a dense output layer with neurons equal to the number of classes\n", + "\n", + "We will define a few variables to get started:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "input_size = 28 * 28\n", + "n_classes = 24" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do your work in the cell below, creating a `model` variable to store the model. We've imported the [Sequental](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html) model class and [Linear](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html) layer class to get you started. Reveal the solution below for a hint:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "model = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.Linear(input_size,512),\n", + " nn.ReLU(),\n", + " nn.Linear(512,512),\n", + " nn.ReLU(),\n", + " nn.Linear(512,n_classes),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Solution" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_WckEGM9Tr-D" + }, + "outputs": [], + "source": [ + "# SOLUTION\n", + "model = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.Linear(input_size, 512), # Input\n", + " nn.ReLU(), # Activation for input\n", + " nn.Linear(512, 512), # Hidden\n", + " nn.ReLU(), # Activation for hidden\n", + " nn.Linear(512, n_classes) # Output\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This time, we'll combine compiling the model and sending it to the GPU in one step:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 326, + "status": "ok", + "timestamp": 1715068155362, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "TjXGJyWuUGcH", + "outputId": "f3474939-80a3-4715-aea4-991a2629232a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "OptimizedModule(\n", + " (_orig_mod): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=784, out_features=512, bias=True)\n", + " (2): ReLU()\n", + " (3): Linear(in_features=512, out_features=512, bias=True)\n", + " (4): ReLU()\n", + " (5): Linear(in_features=512, out_features=24, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = torch.compile(model.to(device))\n", + "model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since categorizing these ASL images is similar to categorizing MNIST's handwritten digits, we will use the same `loss_function` ([Categorical CrossEntropy](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)) and `optimizer` ([Adam](https://pytorch.org/docs/stable/generated/torch.optim.Adam.html)). `nn.CrossEntropyLoss` includes the softmax function, and is computationally faster when passing class indices as opposed to predicted probabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "LtHYbXz7UZQW" + }, + "outputs": [], + "source": [ + "loss_function = nn.CrossEntropyLoss()\n", + "optimizer = Adam(model.parameters())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.6 Training the Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This time, let's look at our `train` and `validate` functions in more detail." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.6.1 The Train Function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This code is almost the same as in the previous notebook, but we no longer send `x` and `y` to our GPU because our DataLoader already does that.\n", + "\n", + "Before looping through the DataLoader, we will set the model to [model.train](https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.train) to make sure its parameters can be updated. To make it easier for us to follow training progress, we'll keep track of the total `loss` and `accuracy`.\n", + "\n", + "Then, for each batch in our `train_loader`, we will:\n", + "1. Get an `output` prediction from the model\n", + "2. Set the gradient to zero with the `optimizer`'s [zero_grad](https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html) function\n", + "3. Calculate the loss with our `loss_function`\n", + "4. Compute the gradient with [backward](https://pytorch.org/docs/stable/generated/torch.Tensor.backward.html)\n", + "5. Update our model parameters with the `optimizer`'s [step](https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.step.html) function.\n", + "6. Update the `loss` and `accuracy` totals" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "AfgrATXFV_og" + }, + "outputs": [], + "source": [ + "def train():\n", + " loss = 0\n", + " accuracy = 0\n", + "\n", + " model.train()\n", + " for x, y in train_loader:\n", + " output = model(x)\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 += get_batch_accuracy(output, y, train_N)\n", + " print('Train - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.6.2 The Validate Function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model does not learn during validation, so the `validate` function is simpler than the `train` function above.\n", + "\n", + "One key difference is we will set the model to evaluation mode with [model.evaluate](https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.eval), which will prevent the model from updating any parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "8LQcAtcc0ggk" + }, + "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 += get_batch_accuracy(output, y, valid_N)\n", + " print('Valid - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.6.3 Calculating the Accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both the `train` and `validate` functions use `get_batch_accuracy`, but we have not defined that in this notebook yet. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function below has three `FIXME`s. Each one corresponds to the functions input arguments. Can you replace each FIXME with the correct argument?\n", + "\n", + "It may help to view the documentation for [argmax](https://pytorch.org/docs/stable/generated/torch.argmax.html), [eq](https://pytorch.org/docs/stable/generated/torch.eq.html), and [view_as](https://pytorch.org/docs/stable/generated/torch.Tensor.view_as.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def get_batch_accuracy(output, y, N):\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct = pred.eq(y.view_as(pred)).sum().item()\n", + " return correct / N" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Click the `...` below for the solution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# SOLUTION\n", + "def get_batch_accuracy(output, y, N):\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct = pred.eq(y.view_as(pred)).sum().item()\n", + " return correct / N" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.6.3 The Training Loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's bring it all together! Run the cell below to train the data for 20 `epochs`." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 38185, + "status": "ok", + "timestamp": 1715068198222, + "user": { + "displayName": "Danielle Detering US", + "userId": "15432464718872067879" + }, + "user_tz": 420 + }, + "id": "JXzlHJw8-j5L", + "outputId": "40b9eda4-352d-45f5-dc95-4193f7f13423" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0\n", + "Train - Loss: 1544.5647 Accuracy: 0.4139\n", + "Valid - Loss: 300.6098 Accuracy: 0.5432\n", + "Epoch: 1\n", + "Train - Loss: 682.1709 Accuracy: 0.7272\n", + "Valid - Loss: 241.6977 Accuracy: 0.6644\n", + "Epoch: 2\n", + "Train - Loss: 356.0020 Accuracy: 0.8608\n", + "Valid - Loss: 207.0941 Accuracy: 0.7241\n", + "Epoch: 3\n", + "Train - Loss: 212.9807 Accuracy: 0.9189\n", + "Valid - Loss: 222.7968 Accuracy: 0.7469\n", + "Epoch: 4\n", + "Train - Loss: 120.5757 Accuracy: 0.9571\n", + "Valid - Loss: 212.5262 Accuracy: 0.7851\n", + "Epoch: 5\n", + "Train - Loss: 90.5495 Accuracy: 0.9672\n", + "Valid - Loss: 270.4961 Accuracy: 0.7196\n", + "Epoch: 6\n", + "Train - Loss: 52.9683 Accuracy: 0.9828\n", + "Valid - Loss: 346.0175 Accuracy: 0.7058\n", + "Epoch: 7\n", + "Train - Loss: 60.2388 Accuracy: 0.9786\n", + "Valid - Loss: 243.9202 Accuracy: 0.7899\n", + "Epoch: 8\n", + "Train - Loss: 66.6491 Accuracy: 0.9772\n", + "Valid - Loss: 231.9360 Accuracy: 0.7985\n", + "Epoch: 9\n", + "Train - Loss: 57.7538 Accuracy: 0.9792\n", + "Valid - Loss: 260.8650 Accuracy: 0.7777\n", + "Epoch: 10\n", + "Train - Loss: 4.7490 Accuracy: 0.9995\n", + "Valid - Loss: 249.2714 Accuracy: 0.7962\n", + "Epoch: 11\n", + "Train - Loss: 87.3801 Accuracy: 0.9695\n", + "Valid - Loss: 263.7915 Accuracy: 0.7554\n", + "Epoch: 12\n", + "Train - Loss: 25.1833 Accuracy: 0.9913\n", + "Valid - Loss: 336.0438 Accuracy: 0.7323\n", + "Epoch: 13\n", + "Train - Loss: 22.2535 Accuracy: 0.9921\n", + "Valid - Loss: 254.7867 Accuracy: 0.8081\n", + "Epoch: 14\n", + "Train - Loss: 1.0967 Accuracy: 1.0000\n", + "Valid - Loss: 258.9991 Accuracy: 0.8115\n", + "Epoch: 15\n", + "Train - Loss: 0.7421 Accuracy: 1.0000\n", + "Valid - Loss: 263.6500 Accuracy: 0.8111\n", + "Epoch: 16\n", + "Train - Loss: 97.4083 Accuracy: 0.9700\n", + "Valid - Loss: 225.1667 Accuracy: 0.7959\n", + "Epoch: 17\n", + "Train - Loss: 3.6141 Accuracy: 0.9999\n", + "Valid - Loss: 243.8400 Accuracy: 0.8033\n", + "Epoch: 18\n", + "Train - Loss: 50.2676 Accuracy: 0.9828\n", + "Valid - Loss: 245.1898 Accuracy: 0.7980\n", + "Epoch: 19\n", + "Train - Loss: 1.5806 Accuracy: 1.0000\n", + "Valid - Loss: 255.6030 Accuracy: 0.8058\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": "asDVasm6TjyY" + }, + "source": [ + "### 2.6.4 Discussion: What happened?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YWYAlfHzTjyY" + }, + "source": [ + "We can see that the training accuracy got to a fairly high level, but the validation accuracy was not as high. What happened here?\n", + "\n", + "Think about it for a bit before clicking on the '...' below to reveal the answer." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BGB3jWGRTjyY" + }, + "source": [ + "`# SOLUTION`\n", + "This is an example of the model learning to categorize the training data, but performing poorly against new data that it has not been trained on. Essentially, it is memorizing the dataset, but not gaining a robust and general understanding of the problem. This is a common issue called *overfitting*. We will discuss overfitting in the next two lectures, as well as some ways to address it." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OI5xFCVLTjyY" + }, + "source": [ + "## 2.7 Summary" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cFcIcMOQTjyZ" + }, + "source": [ + "In this section you built your own neural network to perform image classification that is quite accurate. Congrats!\n", + "\n", + "At this point we should be getting somewhat familiar with the process of loading data (including labels), preparing it, creating a model, and then training the model with prepared data." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CDYpo3ByTjyZ" + }, + "source": [ + "### 2.7.1 Clear the Memory\n", + "Before moving on, please execute the following cell to clear up the GPU memory. This is required to move on to the next notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Mm_uKgfxTjyZ" + }, + "outputs": [], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vuUgx9kPTjyZ" + }, + "source": [ + "### 2.7.2 Next" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WeMVBJwMTjyZ" + }, + "source": [ + "Now that you have built some very basic, somewhat effective models, we will begin to learn about more sophisticated models, including *Convolutional Neural Networks*." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QW2ZlBpITjyZ" + }, + "source": [ + "
\"Header\"
" + ] + } + ], + "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 +} -- cgit v1.2.3