![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "V5ABxNIOnyAr"
+ },
+ "outputs": [],
+ "source": [
+ "import torch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# create random tensor\n",
+ "X = torch.rand(size=(7,7))\n",
+ "X,X.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "4sPUYe-AR22P",
+ "outputId": "ff2f59aa-db29-467f-a2ab-a196be08ee1a"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.3142, 0.4865, 0.7705, 0.3263, 0.7264, 0.6868, 0.0522],\n",
+ " [0.5438, 0.9234, 0.6737, 0.3396, 0.4684, 0.9051, 0.9022],\n",
+ " [0.5038, 0.2225, 0.9657, 0.4975, 0.0989, 0.6913, 0.5937],\n",
+ " [0.7634, 0.8749, 0.1176, 0.0565, 0.5362, 0.1045, 0.6571],\n",
+ " [0.2290, 0.1231, 0.1060, 0.2285, 0.8602, 0.9666, 0.6981],\n",
+ " [0.5703, 0.9126, 0.0165, 0.9157, 0.9846, 0.1595, 0.7734],\n",
+ " [0.0339, 0.1776, 0.6518, 0.5989, 0.2043, 0.2849, 0.2325]]),\n",
+ " torch.Size([7, 7]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 3
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create another random tensor\n",
+ "Y = torch.rand(size=(1, 7))\n",
+ "# Perform matrix multiplication\n",
+ "Z = torch.matmul(X, Y.T)\n",
+ "Z, Z.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "RduF2fcySFm8",
+ "outputId": "c85f229b-27d6-4215-8292-adff242d0708"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[1.4617],\n",
+ " [1.7799],\n",
+ " [1.3014],\n",
+ " [0.9893],\n",
+ " [1.7503],\n",
+ " [1.7336],\n",
+ " [0.8774]]),\n",
+ " torch.Size([7, 1]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set manual seed\n",
+ "torch.manual_seed(0)\n",
+ "\n",
+ "# Create two random tensors\n",
+ "X = torch.rand(size=(7, 7))\n",
+ "Y = torch.rand(size=(1, 7))\n",
+ "\n",
+ "# Matrix multiply tensors\n",
+ "Z = torch.matmul(X, Y.T)\n",
+ "Z, Z.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "XJT1P2NBSfMu",
+ "outputId": "cf85f2aa-6bf2-4cf9-855d-0e451701d738"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[1.8542],\n",
+ " [1.9611],\n",
+ " [2.2884],\n",
+ " [3.0481],\n",
+ " [1.7067],\n",
+ " [2.5290],\n",
+ " [1.7989]]),\n",
+ " torch.Size([7, 1]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 5
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set random seed on the GPU\n",
+ "torch.cuda.manual_seed(1234)"
+ ],
+ "metadata": {
+ "id": "rcgfaPeMWPg2"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set random seed\n",
+ "torch.manual_seed(1234)\n",
+ "\n",
+ "# Check for access to GPU\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "print(f\"Device: {device}\")\n",
+ "\n",
+ "# Create two random tensors on GPU\n",
+ "tensor_A = torch.rand(size=(2,3)).to(device)\n",
+ "tensor_B = torch.rand(size=(2,3)).to(device)\n",
+ "tensor_A, tensor_B"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "kXGUX9tLWtQR",
+ "outputId": "e715efb1-6115-4218-9c82-df5f494945be"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Device: cpu\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.0290, 0.4019, 0.2598],\n",
+ " [0.3666, 0.0583, 0.7006]]),\n",
+ " tensor([[0.0518, 0.4681, 0.6738],\n",
+ " [0.3315, 0.7837, 0.5631]]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 7
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Perform matmul on tensor_A and tensor_B\n",
+ "tensor_C = torch.matmul(tensor_A, tensor_B.T)\n",
+ "tensor_C, tensor_C.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "EzvxTswjW2GP",
+ "outputId": "1cf4adf2-6618-4b23-b23c-f451f482741d"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.3647, 0.4709],\n",
+ " [0.5184, 0.5617]]),\n",
+ " torch.Size([2, 2]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 9
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Find max\n",
+ "max = torch.max(tensor_C)\n",
+ "\n",
+ "# Find min\n",
+ "min = torch.min(tensor_C)\n",
+ "max, min"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "lHPg2D23XDo6",
+ "outputId": "140287af-d71f-4e8d-b7c1-03ddb285f902"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor(0.5617), tensor(0.3647))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 10
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Find arg max\n",
+ "arg_max = torch.argmax(tensor_C)\n",
+ "\n",
+ "# Find arg min\n",
+ "arg_min = torch.argmin(tensor_C)\n",
+ "arg_max, arg_min"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6Fcr_F6QXK_r",
+ "outputId": "b6045ba0-92a8-472f-de2f-104187b1b546"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor(3), tensor(0))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 11
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set seed\n",
+ "torch.manual_seed(7)\n",
+ "\n",
+ "# Create random tensor\n",
+ "tensor_D = torch.rand(size=(1, 1, 1, 10))\n",
+ "\n",
+ "# Remove single dimensions\n",
+ "tensor_E = tensor_D.squeeze()\n",
+ "\n",
+ "# Print out tensors\n",
+ "print(tensor_D, tensor_D.shape)\n",
+ "print(tensor_E, tensor_E.shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "f9OBG49yXRVN",
+ "outputId": "e96e91a7-a407-4660-bba7-9867b3f6bb7f"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n",
+ " 0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n",
+ "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n",
+ " 0.8513]) torch.Size([10])\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "tz9_OxvrXXyr"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb
new file mode 100644
index 0000000..c51d81f
--- /dev/null
+++ b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb
@@ -0,0 +1,724 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 01. PyTorch Workflow Exercise Template\n",
+ "\n",
+ "The following is a template for the PyTorch workflow exercises.\n",
+ "\n",
+ "It's only starter code and it's your job to fill in the blanks.\n",
+ "\n",
+ "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
+ "\n",
+ "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
+ "\n",
+ "You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
+ ],
+ "metadata": {
+ "id": "N8LsPXZti9Sw"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import necessary libraries\n",
+ "import torch\n",
+ "import matplotlib.pyplot as plt\n",
+ "from torch import nn"
+ ],
+ "metadata": {
+ "id": "Glu2fM4dkNlx"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Setup device-agnostic code\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n"
+ ],
+ "metadata": {
+ "id": "LqKhXY26m31s",
+ "outputId": "0e6e7442-e4c8-4869-954b-27c7aae6f1da",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 35
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'cuda'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 28
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. Create a straight line dataset using the linear regression formula (`weight * X + bias`).\n",
+ " * Set `weight=0.3` and `bias=0.9` there should be at least 100 datapoints total.\n",
+ " * Split the data into 80% training, 20% testing.\n",
+ " * Plot the training and testing data so it becomes visual.\n",
+ "\n",
+ "Your output of the below cell should look something like:\n",
+ "```\n",
+ "Number of X samples: 100\n",
+ "Number of y samples: 100\n",
+ "First 10 X & y samples:\n",
+ "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n",
+ " 0.0900])\n",
+ "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n",
+ " 0.9270])\n",
+ "```\n",
+ "\n",
+ "Of course the numbers in `X` and `y` may be different but ideally they're created using the linear regression formula."
+ ],
+ "metadata": {
+ "id": "g7HUhxCxjeBx"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create the data parameters\n",
+ "weight = 0.3\n",
+ "bias = 0.9\n",
+ "# Make X and y using linear regression feature\n",
+ "X = torch.arange(0,1,0.01).unsqueeze(dim = 1)\n",
+ "y = weight * X + bias\n",
+ "print(f\"Number of X samples: {len(X)}\")\n",
+ "print(f\"Number of y samples: {len(y)}\")\n",
+ "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")"
+ ],
+ "metadata": {
+ "id": "KbDG5MV7jhvE",
+ "outputId": "a2868ed1-4ca1-4a4d-eae8-8ff4bf6d9996",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Number of X samples: 100\n",
+ "Number of y samples: 100\n",
+ "First 10 X & y samples:\n",
+ "X: tensor([[0.0000],\n",
+ " [0.0100],\n",
+ " [0.0200],\n",
+ " [0.0300],\n",
+ " [0.0400],\n",
+ " [0.0500],\n",
+ " [0.0600],\n",
+ " [0.0700],\n",
+ " [0.0800],\n",
+ " [0.0900]])\n",
+ "y: tensor([[0.9000],\n",
+ " [0.9030],\n",
+ " [0.9060],\n",
+ " [0.9090],\n",
+ " [0.9120],\n",
+ " [0.9150],\n",
+ " [0.9180],\n",
+ " [0.9210],\n",
+ " [0.9240],\n",
+ " [0.9270]])\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Split the data into training and testing\n",
+ "train_split = int(len(X) * 0.8)\n",
+ "X_train = X[:train_split]\n",
+ "y_train = y[:train_split]\n",
+ "X_test = X[train_split:]\n",
+ "y_test = y[train_split:]\n",
+ "len(X_train),len(y_train),len(X_test),len(y_test)\n"
+ ],
+ "metadata": {
+ "id": "GlwtT1djkmLw",
+ "outputId": "1b5f0c58-8f26-4df8-885e-e0203eeb9a09",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(80, 80, 20, 20)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 30
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Plot the training and testing data\n",
+ "def plot_predictions(train_data = X_train,\n",
+ " train_labels = y_train,\n",
+ " test_data = X_test,\n",
+ " test_labels = y_test,\n",
+ " predictions = None):\n",
+ " plt.figure(figsize = (10,7))\n",
+ " plt.scatter(train_data,train_labels,c = 'r',s = 5,label = \"Training data\")\n",
+ " plt.scatter(test_data,test_labels,c = 'b',s = 5,label = \"Test data\")\n",
+ "\n",
+ " if predictions is not None:\n",
+ " plt.scatter(test_data,predictions,c = 'g',s = 5,label = \"Predictions\")\n",
+ " plt.legend(prop = {\"size\" : 10})\n",
+ "plot_predictions()\n"
+ ],
+ "metadata": {
+ "id": "29iQZFNhlYJ-",
+ "outputId": "b97b8c89-ff33-4ae0-ec64-195249ecfdf8",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 599
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 02. PyTorch Classification Exercises\n",
+ "\n",
+ "The following is a template for 02. PyTorch Classification exercises.\n",
+ "\n",
+ "It's only starter code and it's your job to fill in the blanks.\n",
+ "\n",
+ "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
+ "\n",
+ "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
+ "\n",
+ "## Resources\n",
+ "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n",
+ "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
+ ],
+ "metadata": {
+ "id": "ZKJFt7YxH8yl"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import torch\n",
+ "import torch\n",
+ "\n",
+ "# Setup device agnostic code\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n",
+ "\n",
+ "# Setup random seed\n",
+ "RANDOM_SEED = 42"
+ ],
+ "metadata": {
+ "id": "CSrUPgapO0tf"
+ },
+ "execution_count": 15,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n",
+ " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n",
+ " * Turn the data into PyTorch tensors.\n",
+ " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing."
+ ],
+ "metadata": {
+ "id": "pH7jIZ2SPFee"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create a dataset with Scikit-Learn's make_moons()\n",
+ "from sklearn.datasets import make_moons\n",
+ "NUM_SAMPLES = 1000\n",
+ "X, y = make_moons(n_samples=NUM_SAMPLES,\n",
+ " noise=0.07,\n",
+ " random_state=RANDOM_SEED)\n",
+ "\n",
+ "X[:10], y[:10]"
+ ],
+ "metadata": {
+ "id": "5t4VhPV1PX1X",
+ "outputId": "88e33069-75ee-48cd-8e9f-06669f7db812",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": 16,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(array([[-0.03341062, 0.4213911 ],\n",
+ " [ 0.99882703, -0.4428903 ],\n",
+ " [ 0.88959204, -0.32784256],\n",
+ " [ 0.34195829, -0.41768975],\n",
+ " [-0.83853099, 0.53237483],\n",
+ " [ 0.59906425, -0.28977331],\n",
+ " [ 0.29009023, -0.2046885 ],\n",
+ " [-0.03826868, 0.45942924],\n",
+ " [ 1.61377123, -0.2939697 ],\n",
+ " [ 0.693337 , 0.82781911]]),\n",
+ " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 16
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Turn data into a DataFrame\n",
+ "import pandas as pd\n",
+ "data_df = pd.DataFrame({\"X0\": X[:, 0],\n",
+ " \"X1\": X[:, 1],\n",
+ " \"y\": y})\n",
+ "data_df.head()"
+ ],
+ "metadata": {
+ "id": "SUeHZ3-3P9C7",
+ "outputId": "7ab24745-f8e6-46cc-8a14-5053c4aa3223",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 206
+ }
+ },
+ "execution_count": 17,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ " X0 X1 y\n",
+ "0 -0.033411 0.421391 1\n",
+ "1 0.998827 -0.442890 1\n",
+ "2 0.889592 -0.327843 1\n",
+ "3 0.341958 -0.417690 1\n",
+ "4 -0.838531 0.532375 0"
+ ],
+ "text/html": [
+ "\n",
+ " | \n", + " | X0 | \n", + "X1 | \n", + "y | \n", + "
|---|---|---|---|
| 0 | \n", + "-0.033411 | \n", + "0.421391 | \n", + "1 | \n", + "
| 1 | \n", + "0.998827 | \n", + "-0.442890 | \n", + "1 | \n", + "
| 2 | \n", + "0.889592 | \n", + "-0.327843 | \n", + "1 | \n", + "
| 3 | \n", + "0.341958 | \n", + "-0.417690 | \n", + "1 | \n", + "
| 4 | \n", + "-0.838531 | \n", + "0.532375 | \n", + "0 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "V5ABxNIOnyAr"
+ },
+ "outputs": [],
+ "source": [
+ "import torch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# create random tensor\n",
+ "X = torch.rand(size=(7,7))\n",
+ "X,X.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "4sPUYe-AR22P",
+ "outputId": "ff2f59aa-db29-467f-a2ab-a196be08ee1a"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.3142, 0.4865, 0.7705, 0.3263, 0.7264, 0.6868, 0.0522],\n",
+ " [0.5438, 0.9234, 0.6737, 0.3396, 0.4684, 0.9051, 0.9022],\n",
+ " [0.5038, 0.2225, 0.9657, 0.4975, 0.0989, 0.6913, 0.5937],\n",
+ " [0.7634, 0.8749, 0.1176, 0.0565, 0.5362, 0.1045, 0.6571],\n",
+ " [0.2290, 0.1231, 0.1060, 0.2285, 0.8602, 0.9666, 0.6981],\n",
+ " [0.5703, 0.9126, 0.0165, 0.9157, 0.9846, 0.1595, 0.7734],\n",
+ " [0.0339, 0.1776, 0.6518, 0.5989, 0.2043, 0.2849, 0.2325]]),\n",
+ " torch.Size([7, 7]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 3
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create another random tensor\n",
+ "Y = torch.rand(size=(1, 7))\n",
+ "# Perform matrix multiplication\n",
+ "Z = torch.matmul(X, Y.T)\n",
+ "Z, Z.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "RduF2fcySFm8",
+ "outputId": "c85f229b-27d6-4215-8292-adff242d0708"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[1.4617],\n",
+ " [1.7799],\n",
+ " [1.3014],\n",
+ " [0.9893],\n",
+ " [1.7503],\n",
+ " [1.7336],\n",
+ " [0.8774]]),\n",
+ " torch.Size([7, 1]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set manual seed\n",
+ "torch.manual_seed(0)\n",
+ "\n",
+ "# Create two random tensors\n",
+ "X = torch.rand(size=(7, 7))\n",
+ "Y = torch.rand(size=(1, 7))\n",
+ "\n",
+ "# Matrix multiply tensors\n",
+ "Z = torch.matmul(X, Y.T)\n",
+ "Z, Z.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "XJT1P2NBSfMu",
+ "outputId": "cf85f2aa-6bf2-4cf9-855d-0e451701d738"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[1.8542],\n",
+ " [1.9611],\n",
+ " [2.2884],\n",
+ " [3.0481],\n",
+ " [1.7067],\n",
+ " [2.5290],\n",
+ " [1.7989]]),\n",
+ " torch.Size([7, 1]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 5
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set random seed on the GPU\n",
+ "torch.cuda.manual_seed(1234)"
+ ],
+ "metadata": {
+ "id": "rcgfaPeMWPg2"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set random seed\n",
+ "torch.manual_seed(1234)\n",
+ "\n",
+ "# Check for access to GPU\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "print(f\"Device: {device}\")\n",
+ "\n",
+ "# Create two random tensors on GPU\n",
+ "tensor_A = torch.rand(size=(2,3)).to(device)\n",
+ "tensor_B = torch.rand(size=(2,3)).to(device)\n",
+ "tensor_A, tensor_B"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "kXGUX9tLWtQR",
+ "outputId": "e715efb1-6115-4218-9c82-df5f494945be"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Device: cpu\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.0290, 0.4019, 0.2598],\n",
+ " [0.3666, 0.0583, 0.7006]]),\n",
+ " tensor([[0.0518, 0.4681, 0.6738],\n",
+ " [0.3315, 0.7837, 0.5631]]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 7
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Perform matmul on tensor_A and tensor_B\n",
+ "tensor_C = torch.matmul(tensor_A, tensor_B.T)\n",
+ "tensor_C, tensor_C.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "EzvxTswjW2GP",
+ "outputId": "1cf4adf2-6618-4b23-b23c-f451f482741d"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.3647, 0.4709],\n",
+ " [0.5184, 0.5617]]),\n",
+ " torch.Size([2, 2]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 9
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Find max\n",
+ "max = torch.max(tensor_C)\n",
+ "\n",
+ "# Find min\n",
+ "min = torch.min(tensor_C)\n",
+ "max, min"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "lHPg2D23XDo6",
+ "outputId": "140287af-d71f-4e8d-b7c1-03ddb285f902"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor(0.5617), tensor(0.3647))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 10
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Find arg max\n",
+ "arg_max = torch.argmax(tensor_C)\n",
+ "\n",
+ "# Find arg min\n",
+ "arg_min = torch.argmin(tensor_C)\n",
+ "arg_max, arg_min"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6Fcr_F6QXK_r",
+ "outputId": "b6045ba0-92a8-472f-de2f-104187b1b546"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor(3), tensor(0))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 11
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set seed\n",
+ "torch.manual_seed(7)\n",
+ "\n",
+ "# Create random tensor\n",
+ "tensor_D = torch.rand(size=(1, 1, 1, 10))\n",
+ "\n",
+ "# Remove single dimensions\n",
+ "tensor_E = tensor_D.squeeze()\n",
+ "\n",
+ "# Print out tensors\n",
+ "print(tensor_D, tensor_D.shape)\n",
+ "print(tensor_E, tensor_E.shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "f9OBG49yXRVN",
+ "outputId": "e96e91a7-a407-4660-bba7-9867b3f6bb7f"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n",
+ " 0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n",
+ "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n",
+ " 0.8513]) torch.Size([10])\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "tz9_OxvrXXyr"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb b/Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb
new file mode 100644
index 0000000..a7cae57
--- /dev/null
+++ b/Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb
@@ -0,0 +1,724 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 01. PyTorch Workflow Exercise Template\n",
+ "\n",
+ "The following is a template for the PyTorch workflow exercises.\n",
+ "\n",
+ "It's only starter code and it's your job to fill in the blanks.\n",
+ "\n",
+ "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
+ "\n",
+ "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
+ "\n",
+ "You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
+ ],
+ "metadata": {
+ "id": "N8LsPXZti9Sw"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import necessary libraries\n",
+ "import torch\n",
+ "import matplotlib.pyplot as plt\n",
+ "from torch import nn"
+ ],
+ "metadata": {
+ "id": "Glu2fM4dkNlx"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Setup device-agnostic code\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n"
+ ],
+ "metadata": {
+ "id": "LqKhXY26m31s",
+ "outputId": "0e6e7442-e4c8-4869-954b-27c7aae6f1da",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 35
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'cuda'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 28
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. Create a straight line dataset using the linear regression formula (`weight * X + bias`).\n",
+ " * Set `weight=0.3` and `bias=0.9` there should be at least 100 datapoints total.\n",
+ " * Split the data into 80% training, 20% testing.\n",
+ " * Plot the training and testing data so it becomes visual.\n",
+ "\n",
+ "Your output of the below cell should look something like:\n",
+ "```\n",
+ "Number of X samples: 100\n",
+ "Number of y samples: 100\n",
+ "First 10 X & y samples:\n",
+ "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n",
+ " 0.0900])\n",
+ "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n",
+ " 0.9270])\n",
+ "```\n",
+ "\n",
+ "Of course the numbers in `X` and `y` may be different but ideally they're created using the linear regression formula."
+ ],
+ "metadata": {
+ "id": "g7HUhxCxjeBx"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create the data parameters\n",
+ "weight = 0.3\n",
+ "bias = 0.9\n",
+ "# Make X and y using linear regression feature\n",
+ "X = torch.arange(0,1,0.01).unsqueeze(dim = 1)\n",
+ "y = weight * X + bias\n",
+ "print(f\"Number of X samples: {len(X)}\")\n",
+ "print(f\"Number of y samples: {len(y)}\")\n",
+ "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")"
+ ],
+ "metadata": {
+ "id": "KbDG5MV7jhvE",
+ "outputId": "a2868ed1-4ca1-4a4d-eae8-8ff4bf6d9996",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Number of X samples: 100\n",
+ "Number of y samples: 100\n",
+ "First 10 X & y samples:\n",
+ "X: tensor([[0.0000],\n",
+ " [0.0100],\n",
+ " [0.0200],\n",
+ " [0.0300],\n",
+ " [0.0400],\n",
+ " [0.0500],\n",
+ " [0.0600],\n",
+ " [0.0700],\n",
+ " [0.0800],\n",
+ " [0.0900]])\n",
+ "y: tensor([[0.9000],\n",
+ " [0.9030],\n",
+ " [0.9060],\n",
+ " [0.9090],\n",
+ " [0.9120],\n",
+ " [0.9150],\n",
+ " [0.9180],\n",
+ " [0.9210],\n",
+ " [0.9240],\n",
+ " [0.9270]])\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Split the data into training and testing\n",
+ "train_split = int(len(X) * 0.8)\n",
+ "X_train = X[:train_split]\n",
+ "y_train = y[:train_split]\n",
+ "X_test = X[train_split:]\n",
+ "y_test = y[train_split:]\n",
+ "len(X_train),len(y_train),len(X_test),len(y_test)\n"
+ ],
+ "metadata": {
+ "id": "GlwtT1djkmLw",
+ "outputId": "1b5f0c58-8f26-4df8-885e-e0203eeb9a09",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(80, 80, 20, 20)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 30
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Plot the training and testing data\n",
+ "def plot_predictions(train_data = X_train,\n",
+ " train_labels = y_train,\n",
+ " test_data = X_test,\n",
+ " test_labels = y_test,\n",
+ " predictions = None):\n",
+ " plt.figure(figsize = (10,7))\n",
+ " plt.scatter(train_data,train_labels,c = 'r',s = 5,label = \"Training data\")\n",
+ " plt.scatter(test_data,test_labels,c = 'b',s = 5,label = \"Test data\")\n",
+ "\n",
+ " if predictions is not None:\n",
+ " plt.scatter(test_data,predictions,c = 'g',s = 5,label = \"Predictions\")\n",
+ " plt.legend(prop = {\"size\" : 10})\n",
+ "plot_predictions()\n"
+ ],
+ "metadata": {
+ "id": "29iQZFNhlYJ-",
+ "outputId": "b97b8c89-ff33-4ae0-ec64-195249ecfdf8",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 599
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 02. PyTorch Classification Exercises\n",
+ "\n",
+ "The following is a template for 02. PyTorch Classification exercises.\n",
+ "\n",
+ "It's only starter code and it's your job to fill in the blanks.\n",
+ "\n",
+ "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
+ "\n",
+ "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
+ "\n",
+ "## Resources\n",
+ "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n",
+ "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
+ ],
+ "metadata": {
+ "id": "ZKJFt7YxH8yl"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import torch\n",
+ "import torch\n",
+ "\n",
+ "# Setup device agnostic code\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n",
+ "\n",
+ "# Setup random seed\n",
+ "RANDOM_SEED = 42"
+ ],
+ "metadata": {
+ "id": "CSrUPgapO0tf"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n",
+ " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n",
+ " * Turn the data into PyTorch tensors.\n",
+ " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing."
+ ],
+ "metadata": {
+ "id": "pH7jIZ2SPFee"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create a dataset with Scikit-Learn's make_moons()\n",
+ "from sklearn.datasets import make_moons\n",
+ "NUM_SAMPLES = 1000\n",
+ "X, y = make_moons(n_samples=NUM_SAMPLES,\n",
+ " noise=0.07,\n",
+ " random_state=RANDOM_SEED)\n",
+ "\n",
+ "X[:10], y[:10]"
+ ],
+ "metadata": {
+ "id": "5t4VhPV1PX1X",
+ "outputId": "88e33069-75ee-48cd-8e9f-06669f7db812",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(array([[-0.03341062, 0.4213911 ],\n",
+ " [ 0.99882703, -0.4428903 ],\n",
+ " [ 0.88959204, -0.32784256],\n",
+ " [ 0.34195829, -0.41768975],\n",
+ " [-0.83853099, 0.53237483],\n",
+ " [ 0.59906425, -0.28977331],\n",
+ " [ 0.29009023, -0.2046885 ],\n",
+ " [-0.03826868, 0.45942924],\n",
+ " [ 1.61377123, -0.2939697 ],\n",
+ " [ 0.693337 , 0.82781911]]),\n",
+ " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 16
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Turn data into a DataFrame\n",
+ "import pandas as pd\n",
+ "data_df = pd.DataFrame({\"X0\": X[:, 0],\n",
+ " \"X1\": X[:, 1],\n",
+ " \"y\": y})\n",
+ "data_df.head()"
+ ],
+ "metadata": {
+ "id": "SUeHZ3-3P9C7",
+ "outputId": "7ab24745-f8e6-46cc-8a14-5053c4aa3223",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 206
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ " X0 X1 y\n",
+ "0 -0.033411 0.421391 1\n",
+ "1 0.998827 -0.442890 1\n",
+ "2 0.889592 -0.327843 1\n",
+ "3 0.341958 -0.417690 1\n",
+ "4 -0.838531 0.532375 0"
+ ],
+ "text/html": [
+ "\n",
+ " | \n", + " | X0 | \n", + "X1 | \n", + "y | \n", + "
|---|---|---|---|
| 0 | \n", + "-0.033411 | \n", + "0.421391 | \n", + "1 | \n", + "
| 1 | \n", + "0.998827 | \n", + "-0.442890 | \n", + "1 | \n", + "
| 2 | \n", + "0.889592 | \n", + "-0.327843 | \n", + "1 | \n", + "
| 3 | \n", + "0.341958 | \n", + "-0.417690 | \n", + "1 | \n", + "
| 4 | \n", + "-0.838531 | \n", + "0.532375 | \n", + "0 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 02. PyTorch Classification Exercises\n",
+ "\n",
+ "The following is a template for 02. PyTorch Classification exercises.\n",
+ "\n",
+ "It's only starter code and it's your job to fill in the blanks.\n",
+ "\n",
+ "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
+ "\n",
+ "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
+ "\n",
+ "## Resources\n",
+ "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n",
+ "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
+ ],
+ "metadata": {
+ "id": "ZKJFt7YxH8yl"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import torch\n",
+ "import torch\n",
+ "\n",
+ "# Setup device agnostic code\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n",
+ "\n",
+ "# Setup random seed\n",
+ "RANDOM_SEED = 42"
+ ],
+ "metadata": {
+ "id": "CSrUPgapO0tf"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n",
+ " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n",
+ " * Turn the data into PyTorch tensors.\n",
+ " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing."
+ ],
+ "metadata": {
+ "id": "pH7jIZ2SPFee"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create a dataset with Scikit-Learn's make_moons()\n",
+ "from sklearn.datasets import make_moons\n",
+ "NUM_SAMPLES = 1000\n",
+ "X, y = make_moons(n_samples=NUM_SAMPLES,\n",
+ " noise=0.07,\n",
+ " random_state=RANDOM_SEED)\n",
+ "\n",
+ "X[:10], y[:10]"
+ ],
+ "metadata": {
+ "id": "5t4VhPV1PX1X",
+ "outputId": "88e33069-75ee-48cd-8e9f-06669f7db812",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(array([[-0.03341062, 0.4213911 ],\n",
+ " [ 0.99882703, -0.4428903 ],\n",
+ " [ 0.88959204, -0.32784256],\n",
+ " [ 0.34195829, -0.41768975],\n",
+ " [-0.83853099, 0.53237483],\n",
+ " [ 0.59906425, -0.28977331],\n",
+ " [ 0.29009023, -0.2046885 ],\n",
+ " [-0.03826868, 0.45942924],\n",
+ " [ 1.61377123, -0.2939697 ],\n",
+ " [ 0.693337 , 0.82781911]]),\n",
+ " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 16
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Turn data into a DataFrame\n",
+ "import pandas as pd\n",
+ "data_df = pd.DataFrame({\"X0\": X[:, 0],\n",
+ " \"X1\": X[:, 1],\n",
+ " \"y\": y})\n",
+ "data_df.head()"
+ ],
+ "metadata": {
+ "id": "SUeHZ3-3P9C7",
+ "outputId": "7ab24745-f8e6-46cc-8a14-5053c4aa3223",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 206
+ }
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ " X0 X1 y\n",
+ "0 -0.033411 0.421391 1\n",
+ "1 0.998827 -0.442890 1\n",
+ "2 0.889592 -0.327843 1\n",
+ "3 0.341958 -0.417690 1\n",
+ "4 -0.838531 0.532375 0"
+ ],
+ "text/html": [
+ "\n",
+ " | \n", + " | X0 | \n", + "X1 | \n", + "y | \n", + "
|---|---|---|---|
| 0 | \n", + "-0.033411 | \n", + "0.421391 | \n", + "1 | \n", + "
| 1 | \n", + "0.998827 | \n", + "-0.442890 | \n", + "1 | \n", + "
| 2 | \n", + "0.889592 | \n", + "-0.327843 | \n", + "1 | \n", + "
| 3 | \n", + "0.341958 | \n", + "-0.417690 | \n", + "1 | \n", + "
| 4 | \n", + "-0.838531 | \n", + "0.532375 | \n", + "0 | \n", + "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 03. PyTorch Computer Vision Exercises\n",
+ "\n",
+ "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n",
+ "\n",
+ "They're a bunch of fun.\n",
+ "\n",
+ "You're going to get to write plenty of code!\n",
+ "\n",
+ "## Resources\n",
+ "\n",
+ "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n",
+ "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n",
+ " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n",
+ "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)."
+ ],
+ "metadata": {
+ "id": "Vex99np2wFVt"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Check for GPU\n",
+ "!nvidia-smi"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "GaeYzOTLwWh2",
+ "outputId": "4e093661-df6c-4507-fe47-c979c6544f8d"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Wed Apr 23 14:56:22 2025 \n",
+ "+-----------------------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n",
+ "|-----------------------------------------+------------------------+----------------------+\n",
+ "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|=========================================+========================+======================|\n",
+ "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n",
+ "| N/A 66C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-----------------------------------------+------------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=========================================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------------------+\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import torch\n",
+ "import torch\n",
+ "\n",
+ "# Exercises require PyTorch > 1.10.0\n",
+ "print(torch.__version__)\n",
+ "\n",
+ "# TODO: Setup device agnostic code\n",
+ "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 52
+ },
+ "id": "DNwZLMbCzJLk",
+ "outputId": "67260ac6-de01-4400-9a6e-3c752e1e325d"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "2.6.0+cu124\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'cuda'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 2
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. What are 3 areas in industry where computer vision is currently being used?"
+ ],
+ "metadata": {
+ "id": "FSFX7tc1w-en"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n",
+ "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n",
+ "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n"
+ ],
+ "metadata": {
+ "id": "ZOnG1GHLZKMc"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find."
+ ],
+ "metadata": {
+ "id": "oBK-WI6YxDYa"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n"
+ ],
+ "metadata": {
+ "id": "xOtfv8elZwOI"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n",
+ "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those."
+ ],
+ "metadata": {
+ "id": "XeYFEqw8xK26"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n",
+ "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n",
+ "3. Randomly turns off neurons during training to prevent dependency on specific features.\n"
+ ],
+ "metadata": {
+ "id": "LswlbpepaAIG"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n",
+ "\n",
+ "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it."
+ ],
+ "metadata": {
+ "id": "DKdEEFEqxM-8"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets."
+ ],
+ "metadata": {
+ "id": "lvf-3pODxXYI"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import torch\n",
+ "import torchvision\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define transform\n",
+ "transform = transforms.Compose([\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.1307,), (0.3081,))\n",
+ "])\n",
+ "\n",
+ "# Load train and test datasets\n",
+ "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n",
+ "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n",
+ "\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "SHjeuN81bHza"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "train_data, test_data"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "R_uWK0KpFFep",
+ "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(Dataset MNIST\n",
+ " Number of datapoints: 60000\n",
+ " Root location: ./data\n",
+ " Split: Train\n",
+ " StandardTransform\n",
+ " Transform: Compose(\n",
+ " ToTensor()\n",
+ " Normalize(mean=(0.1307,), std=(0.3081,))\n",
+ " ),\n",
+ " Dataset MNIST\n",
+ " Number of datapoints: 10000\n",
+ " Root location: ./data\n",
+ " Split: Test\n",
+ " StandardTransform\n",
+ " Transform: Compose(\n",
+ " ToTensor()\n",
+ " Normalize(mean=(0.1307,), std=(0.3081,))\n",
+ " ))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 21
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "len(train_data), len(test_data)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ePSUg0oGEoHF",
+ "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(60000, 10000)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 22
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Get the class names from the dataset\n",
+ "class_names = train_data.classes\n",
+ "class_names\n"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "TN6d1nUxD_64",
+ "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "['0 - zero',\n",
+ " '1 - one',\n",
+ " '2 - two',\n",
+ " '3 - three',\n",
+ " '4 - four',\n",
+ " '5 - five',\n",
+ " '6 - six',\n",
+ " '7 - seven',\n",
+ " '8 - eight',\n",
+ " '9 - nine']"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 23
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 6. Visualize at least 5 different samples of the MNIST training dataset."
+ ],
+ "metadata": {
+ "id": "qxZW-uAbxe_F"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Function to visualize images\n",
+ "def show_images(dataset, num_images=5):\n",
+ " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n",
+ " for i in range(num_images):\n",
+ " img, label = dataset[i]\n",
+ " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n",
+ " axes[i].set_title(f\"Label: {label}\")\n",
+ " axes[i].axis(\"off\")\n",
+ "\n",
+ "show_images(train_data)\n"
+ ],
+ "metadata": {
+ "id": "QVFsYi1PbItE",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 155
+ },
+ "outputId": "ac991564-8773-4a32-b49f-273fd1284fea"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 03. PyTorch Computer Vision Exercises\n",
+ "\n",
+ "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n",
+ "\n",
+ "They're a bunch of fun.\n",
+ "\n",
+ "You're going to get to write plenty of code!\n",
+ "\n",
+ "## Resources\n",
+ "\n",
+ "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n",
+ "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n",
+ " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n",
+ "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)."
+ ],
+ "metadata": {
+ "id": "Vex99np2wFVt"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Check for GPU\n",
+ "!nvidia-smi"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "GaeYzOTLwWh2",
+ "outputId": "4e093661-df6c-4507-fe47-c979c6544f8d"
+ },
+ "execution_count": 1,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Wed Apr 23 14:56:22 2025 \n",
+ "+-----------------------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n",
+ "|-----------------------------------------+------------------------+----------------------+\n",
+ "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|=========================================+========================+======================|\n",
+ "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n",
+ "| N/A 66C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-----------------------------------------+------------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=========================================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------------------+\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import torch\n",
+ "import torch\n",
+ "\n",
+ "# Exercises require PyTorch > 1.10.0\n",
+ "print(torch.__version__)\n",
+ "\n",
+ "# TODO: Setup device agnostic code\n",
+ "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 52
+ },
+ "id": "DNwZLMbCzJLk",
+ "outputId": "67260ac6-de01-4400-9a6e-3c752e1e325d"
+ },
+ "execution_count": 2,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "2.6.0+cu124\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'cuda'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 2
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. What are 3 areas in industry where computer vision is currently being used?"
+ ],
+ "metadata": {
+ "id": "FSFX7tc1w-en"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "VyWRkvWGbCXj"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n",
+ "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n",
+ "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n"
+ ],
+ "metadata": {
+ "id": "ZOnG1GHLZKMc"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find."
+ ],
+ "metadata": {
+ "id": "oBK-WI6YxDYa"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "d1rxD6GObCqh"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n"
+ ],
+ "metadata": {
+ "id": "xOtfv8elZwOI"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n",
+ "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those."
+ ],
+ "metadata": {
+ "id": "XeYFEqw8xK26"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n",
+ "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n",
+ "3. Randomly turns off neurons during training to prevent dependency on specific features.\n"
+ ],
+ "metadata": {
+ "id": "LswlbpepaAIG"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n",
+ "\n",
+ "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it."
+ ],
+ "metadata": {
+ "id": "DKdEEFEqxM-8"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets."
+ ],
+ "metadata": {
+ "id": "lvf-3pODxXYI"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import torch\n",
+ "import torchvision\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define transform\n",
+ "transform = transforms.Compose([\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.1307,), (0.3081,))\n",
+ "])\n",
+ "\n",
+ "# Load train and test datasets\n",
+ "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n",
+ "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n",
+ "\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "SHjeuN81bHza"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "train_data, test_data"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "R_uWK0KpFFep",
+ "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(Dataset MNIST\n",
+ " Number of datapoints: 60000\n",
+ " Root location: ./data\n",
+ " Split: Train\n",
+ " StandardTransform\n",
+ " Transform: Compose(\n",
+ " ToTensor()\n",
+ " Normalize(mean=(0.1307,), std=(0.3081,))\n",
+ " ),\n",
+ " Dataset MNIST\n",
+ " Number of datapoints: 10000\n",
+ " Root location: ./data\n",
+ " Split: Test\n",
+ " StandardTransform\n",
+ " Transform: Compose(\n",
+ " ToTensor()\n",
+ " Normalize(mean=(0.1307,), std=(0.3081,))\n",
+ " ))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 21
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "len(train_data), len(test_data)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ePSUg0oGEoHF",
+ "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(60000, 10000)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 22
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Get the class names from the dataset\n",
+ "class_names = train_data.classes\n",
+ "class_names\n"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "TN6d1nUxD_64",
+ "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "['0 - zero',\n",
+ " '1 - one',\n",
+ " '2 - two',\n",
+ " '3 - three',\n",
+ " '4 - four',\n",
+ " '5 - five',\n",
+ " '6 - six',\n",
+ " '7 - seven',\n",
+ " '8 - eight',\n",
+ " '9 - nine']"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 23
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 6. Visualize at least 5 different samples of the MNIST training dataset."
+ ],
+ "metadata": {
+ "id": "qxZW-uAbxe_F"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Function to visualize images\n",
+ "def show_images(dataset, num_images=5):\n",
+ " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n",
+ " for i in range(num_images):\n",
+ " img, label = dataset[i]\n",
+ " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n",
+ " axes[i].set_title(f\"Label: {label}\")\n",
+ " axes[i].axis(\"off\")\n",
+ "\n",
+ "show_images(train_data)\n"
+ ],
+ "metadata": {
+ "id": "QVFsYi1PbItE",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 155
+ },
+ "outputId": "ac991564-8773-4a32-b49f-273fd1284fea"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 03. PyTorch Computer Vision Exercises\n",
+ "\n",
+ "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n",
+ "\n",
+ "They're a bunch of fun.\n",
+ "\n",
+ "You're going to get to write plenty of code!\n",
+ "\n",
+ "## Resources\n",
+ "\n",
+ "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n",
+ "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n",
+ " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n",
+ "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)."
+ ],
+ "metadata": {
+ "id": "Vex99np2wFVt"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Check for GPU\n",
+ "!nvidia-smi"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "GaeYzOTLwWh2",
+ "outputId": "4e093661-df6c-4507-fe47-c979c6544f8d"
+ },
+ "execution_count": 1,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Wed Apr 23 14:56:22 2025 \n",
+ "+-----------------------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n",
+ "|-----------------------------------------+------------------------+----------------------+\n",
+ "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|=========================================+========================+======================|\n",
+ "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n",
+ "| N/A 66C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-----------------------------------------+------------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=========================================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------------------+\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Import torch\n",
+ "import torch\n",
+ "\n",
+ "# Exercises require PyTorch > 1.10.0\n",
+ "print(torch.__version__)\n",
+ "\n",
+ "# TODO: Setup device agnostic code\n",
+ "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "device\n"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 52
+ },
+ "id": "DNwZLMbCzJLk",
+ "outputId": "67260ac6-de01-4400-9a6e-3c752e1e325d"
+ },
+ "execution_count": 2,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "2.6.0+cu124\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'cuda'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 2
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. What are 3 areas in industry where computer vision is currently being used?"
+ ],
+ "metadata": {
+ "id": "FSFX7tc1w-en"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "VyWRkvWGbCXj"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n",
+ "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n",
+ "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n"
+ ],
+ "metadata": {
+ "id": "ZOnG1GHLZKMc"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find."
+ ],
+ "metadata": {
+ "id": "oBK-WI6YxDYa"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "d1rxD6GObCqh"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n"
+ ],
+ "metadata": {
+ "id": "xOtfv8elZwOI"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n",
+ "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those."
+ ],
+ "metadata": {
+ "id": "XeYFEqw8xK26"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n",
+ "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n",
+ "3. Randomly turns off neurons during training to prevent dependency on specific features.\n"
+ ],
+ "metadata": {
+ "id": "LswlbpepaAIG"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n",
+ "\n",
+ "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it."
+ ],
+ "metadata": {
+ "id": "DKdEEFEqxM-8"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets."
+ ],
+ "metadata": {
+ "id": "lvf-3pODxXYI"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import torch\n",
+ "import torchvision\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define transform\n",
+ "transform = transforms.Compose([\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.1307,), (0.3081,))\n",
+ "])\n",
+ "\n",
+ "# Load train and test datasets\n",
+ "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n",
+ "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n",
+ "\n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "SHjeuN81bHza"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "train_data, test_data"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "R_uWK0KpFFep",
+ "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(Dataset MNIST\n",
+ " Number of datapoints: 60000\n",
+ " Root location: ./data\n",
+ " Split: Train\n",
+ " StandardTransform\n",
+ " Transform: Compose(\n",
+ " ToTensor()\n",
+ " Normalize(mean=(0.1307,), std=(0.3081,))\n",
+ " ),\n",
+ " Dataset MNIST\n",
+ " Number of datapoints: 10000\n",
+ " Root location: ./data\n",
+ " Split: Test\n",
+ " StandardTransform\n",
+ " Transform: Compose(\n",
+ " ToTensor()\n",
+ " Normalize(mean=(0.1307,), std=(0.3081,))\n",
+ " ))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 21
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "len(train_data), len(test_data)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ePSUg0oGEoHF",
+ "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(60000, 10000)"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 22
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Get the class names from the dataset\n",
+ "class_names = train_data.classes\n",
+ "class_names\n"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "TN6d1nUxD_64",
+ "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "['0 - zero',\n",
+ " '1 - one',\n",
+ " '2 - two',\n",
+ " '3 - three',\n",
+ " '4 - four',\n",
+ " '5 - five',\n",
+ " '6 - six',\n",
+ " '7 - seven',\n",
+ " '8 - eight',\n",
+ " '9 - nine']"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 23
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 6. Visualize at least 5 different samples of the MNIST training dataset."
+ ],
+ "metadata": {
+ "id": "qxZW-uAbxe_F"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Function to visualize images\n",
+ "def show_images(dataset, num_images=5):\n",
+ " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n",
+ " for i in range(num_images):\n",
+ " img, label = dataset[i]\n",
+ " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n",
+ " axes[i].set_title(f\"Label: {label}\")\n",
+ " axes[i].axis(\"off\")\n",
+ "\n",
+ "show_images(train_data)\n"
+ ],
+ "metadata": {
+ "id": "QVFsYi1PbItE",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 155
+ },
+ "outputId": "ac991564-8773-4a32-b49f-273fd1284fea"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "V5ABxNIOnyAr"
+ },
+ "outputs": [],
+ "source": [
+ "import torch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# create random tensor\n",
+ "X = torch.rand(size=(7,7))\n",
+ "X,X.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "4sPUYe-AR22P",
+ "outputId": "ff2f59aa-db29-467f-a2ab-a196be08ee1a"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.3142, 0.4865, 0.7705, 0.3263, 0.7264, 0.6868, 0.0522],\n",
+ " [0.5438, 0.9234, 0.6737, 0.3396, 0.4684, 0.9051, 0.9022],\n",
+ " [0.5038, 0.2225, 0.9657, 0.4975, 0.0989, 0.6913, 0.5937],\n",
+ " [0.7634, 0.8749, 0.1176, 0.0565, 0.5362, 0.1045, 0.6571],\n",
+ " [0.2290, 0.1231, 0.1060, 0.2285, 0.8602, 0.9666, 0.6981],\n",
+ " [0.5703, 0.9126, 0.0165, 0.9157, 0.9846, 0.1595, 0.7734],\n",
+ " [0.0339, 0.1776, 0.6518, 0.5989, 0.2043, 0.2849, 0.2325]]),\n",
+ " torch.Size([7, 7]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 3
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Create another random tensor\n",
+ "Y = torch.rand(size=(1, 7))\n",
+ "# Perform matrix multiplication\n",
+ "Z = torch.matmul(X, Y.T)\n",
+ "Z, Z.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "RduF2fcySFm8",
+ "outputId": "c85f229b-27d6-4215-8292-adff242d0708"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[1.4617],\n",
+ " [1.7799],\n",
+ " [1.3014],\n",
+ " [0.9893],\n",
+ " [1.7503],\n",
+ " [1.7336],\n",
+ " [0.8774]]),\n",
+ " torch.Size([7, 1]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set manual seed\n",
+ "torch.manual_seed(0)\n",
+ "\n",
+ "# Create two random tensors\n",
+ "X = torch.rand(size=(7, 7))\n",
+ "Y = torch.rand(size=(1, 7))\n",
+ "\n",
+ "# Matrix multiply tensors\n",
+ "Z = torch.matmul(X, Y.T)\n",
+ "Z, Z.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "XJT1P2NBSfMu",
+ "outputId": "cf85f2aa-6bf2-4cf9-855d-0e451701d738"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[1.8542],\n",
+ " [1.9611],\n",
+ " [2.2884],\n",
+ " [3.0481],\n",
+ " [1.7067],\n",
+ " [2.5290],\n",
+ " [1.7989]]),\n",
+ " torch.Size([7, 1]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 5
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set random seed on the GPU\n",
+ "torch.cuda.manual_seed(1234)"
+ ],
+ "metadata": {
+ "id": "rcgfaPeMWPg2"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set random seed\n",
+ "torch.manual_seed(1234)\n",
+ "\n",
+ "# Check for access to GPU\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "print(f\"Device: {device}\")\n",
+ "\n",
+ "# Create two random tensors on GPU\n",
+ "tensor_A = torch.rand(size=(2,3)).to(device)\n",
+ "tensor_B = torch.rand(size=(2,3)).to(device)\n",
+ "tensor_A, tensor_B"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "kXGUX9tLWtQR",
+ "outputId": "e715efb1-6115-4218-9c82-df5f494945be"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Device: cpu\n"
+ ]
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.0290, 0.4019, 0.2598],\n",
+ " [0.3666, 0.0583, 0.7006]]),\n",
+ " tensor([[0.0518, 0.4681, 0.6738],\n",
+ " [0.3315, 0.7837, 0.5631]]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 7
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Perform matmul on tensor_A and tensor_B\n",
+ "tensor_C = torch.matmul(tensor_A, tensor_B.T)\n",
+ "tensor_C, tensor_C.shape"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "EzvxTswjW2GP",
+ "outputId": "1cf4adf2-6618-4b23-b23c-f451f482741d"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor([[0.3647, 0.4709],\n",
+ " [0.5184, 0.5617]]),\n",
+ " torch.Size([2, 2]))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 9
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Find max\n",
+ "max = torch.max(tensor_C)\n",
+ "\n",
+ "# Find min\n",
+ "min = torch.min(tensor_C)\n",
+ "max, min"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "lHPg2D23XDo6",
+ "outputId": "140287af-d71f-4e8d-b7c1-03ddb285f902"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor(0.5617), tensor(0.3647))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 10
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Find arg max\n",
+ "arg_max = torch.argmax(tensor_C)\n",
+ "\n",
+ "# Find arg min\n",
+ "arg_min = torch.argmin(tensor_C)\n",
+ "arg_max, arg_min"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6Fcr_F6QXK_r",
+ "outputId": "b6045ba0-92a8-472f-de2f-104187b1b546"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "(tensor(3), tensor(0))"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 11
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Set seed\n",
+ "torch.manual_seed(7)\n",
+ "\n",
+ "# Create random tensor\n",
+ "tensor_D = torch.rand(size=(1, 1, 1, 10))\n",
+ "\n",
+ "# Remove single dimensions\n",
+ "tensor_E = tensor_D.squeeze()\n",
+ "\n",
+ "# Print out tensors\n",
+ "print(tensor_D, tensor_D.shape)\n",
+ "print(tensor_E, tensor_E.shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "f9OBG49yXRVN",
+ "outputId": "e96e91a7-a407-4660-bba7-9867b3f6bb7f"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n",
+ " 0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n",
+ "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n",
+ " 0.8513]) torch.Size([10])\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "tz9_OxvrXXyr"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file