{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyP09wkpsnLN30CwU+02KpR6"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU","gpuClass":"standard"},"cells":[{"cell_type":"markdown","source":["# Introduction to PyTorch"],"metadata":{"id":"t4yuhF1aQZpz"}},{"cell_type":"markdown","source":["In this lesson, we will learn the basics of PyTorch, a popular deep learning framework. We will cover the following topics:\n","\n","1. Tensors\n","2. Autograd\n","3. Building a simple neural network"],"metadata":{"id":"viZAQus4Qesj"}},{"cell_type":"markdown","source":["## 1. Tensors\n"],"metadata":{"id":"_1xDXq0IPsRL"}},{"cell_type":"code","source":["import torch\n","\n","# Create a tensor\n","x = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)\n","print(\"x:\", x)\n","\n","# Create a tensor of zeros\n","y = torch.zeros(2, 2)\n","print(\"y:\", y)\n","\n","# Create a tensor of ones\n","z = torch.ones(2, 2)\n","print(\"z:\", z)\n","\n","# Create a random tensor\n","w = torch.rand(2, 2)\n","print(\"w:\", w)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"UZpcjhjuQeiV","executionInfo":{"status":"ok","timestamp":1682720532756,"user_tz":420,"elapsed":7032,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"9e2d9279-1166-4228-c75c-3b1e044143d2"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["x: tensor([[1., 2.],\n","        [3., 4.]])\n","y: tensor([[0., 0.],\n","        [0., 0.]])\n","z: tensor([[1., 1.],\n","        [1., 1.]])\n","w: tensor([[0.6273, 0.7484],\n","        [0.8601, 0.8846]])\n"]}]},{"cell_type":"markdown","source":["## 2. Autograd"],"metadata":{"id":"iwMuEYXxQuam"}},{"cell_type":"code","source":["# Create a tensor with requires_grad=True\n","import torch\n","x = torch.tensor([[1., 2.], [3., 4.]], requires_grad=True)\n","print(\"x:\", x)\n","\n","# Define a simple function\n","y = x * x\n","print(\"y:\", y)\n","\n","# Compute the gradients, to minimize the loss = sum(x*x)\n","loss = y.sum()\n","loss.backward()\n","print(\"Gradients of x:\", x.grad)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"EyqoyMdYQogC","executionInfo":{"status":"ok","timestamp":1682720832262,"user_tz":420,"elapsed":218,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"b9b8c3b5-9d43-4824-f634-4d1112eaa8eb"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["x: tensor([[1., 2.],\n","        [3., 4.]], requires_grad=True)\n","y: tensor([[ 1.,  4.],\n","        [ 9., 16.]], grad_fn=<MulBackward0>)\n","Gradients of x: tensor([[2., 4.],\n","        [6., 8.]])\n"]}]},{"cell_type":"markdown","source":["## 3. Building a simple neural network"],"metadata":{"id":"_5fWpKORRQFO"}},{"cell_type":"code","source":["# Create an instance of the neural network\n","import torch.nn as nn\n","import torch.optim as optim\n","\n","# Define the neural network\n","class SimpleNet(nn.Module):\n","    def __init__(self):\n","        super(SimpleNet, self).__init__()\n","        self.fc1 = nn.Linear(2, 8, bias=False)\n","        self.fc2 = nn.Linear(8, 1)\n","\n","    def forward(self, x):\n","        x = torch.relu(self.fc1(x))\n","        x = self.fc2(x)\n","        return x\n","\n","net = SimpleNet()"],"metadata":{"id":"22JJJ3d9rBrv","executionInfo":{"status":"ok","timestamp":1682715755230,"user_tz":420,"elapsed":7,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}}},"execution_count":16,"outputs":[]},{"cell_type":"code","source":["print(net)\n","\n","# Define the loss function and the optimizer\n","criterion = nn.MSELoss()\n","optimizer = optim.SGD(net.parameters(), lr=0.01)\n","\n","# Prepare some dummy data and labels\n","data = torch.tensor([[1., 2.], [3., 4.]], dtype=torch.float32)\n","labels = torch.tensor([[0.], [1.]], dtype=torch.float32)\n","\n","# Train the neural network\n","for epoch in range(500):\n","    # Forward pass\n","    outputs = net(data)\n","    loss = criterion(outputs, labels)\n","\n","    # IMPORTANT: Zero the gradients\n","    optimizer.zero_grad()\n","\n","    # Backward pass\n","    loss.backward()\n","    optimizer.step()\n","\n","    # Print the loss for this epoch\n","    if (epoch + 1) % 100 == 0:\n","        print(f\"Epoch [{epoch + 1}/{500}], Loss: {loss.item():.4f}\")\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"yh-P4VNDQx0h","executionInfo":{"status":"ok","timestamp":1682715757545,"user_tz":420,"elapsed":7,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"ba034281-6fb5-4913-9809-b5d47689c8b2"},"execution_count":17,"outputs":[{"output_type":"stream","name":"stdout","text":["SimpleNet(\n","  (fc1): Linear(in_features=2, out_features=8, bias=False)\n","  (fc2): Linear(in_features=8, out_features=1, bias=True)\n",")\n","Epoch [100/500], Loss: 0.0726\n","Epoch [200/500], Loss: 0.0367\n","Epoch [300/500], Loss: 0.0181\n","Epoch [400/500], Loss: 0.0088\n","Epoch [500/500], Loss: 0.0042\n"]}]},{"cell_type":"markdown","source":["## 4. PyTorch Datasets and DataLoaders"],"metadata":{"id":"CL495WoAR_Kw"}},{"cell_type":"markdown","source":["Datasets and DataLoaders are essential components for handling data in PyTorch. A Dataset is a collection of data, and a DataLoader helps to efficiently load the data in batches during training.\n","\n","In this example, we'll use the FashionMNIST dataset, which contains 60,000 training images and 10,000 testing images of 10 different clothing items."],"metadata":{"id":"Kw0liepaSDDT"}},{"cell_type":"code","source":["import torchvision\n","import torchvision.transforms as transforms\n","\n","# Define data transformations\n","transform = transforms.Compose([\n","    transforms.Resize(28),\n","    transforms.ToTensor(),\n","    transforms.Normalize((0.5,), (0.5,))\n","])\n","\n","# Load the FashionMNIST dataset\n","train_dataset = torchvision.datasets.FashionMNIST(\n","    root='./data', train=True, download=True, transform=transform\n",")\n","\n","test_dataset = torchvision.datasets.FashionMNIST(\n","    root='./data', train=False, download=True, transform=transform\n",")\n","\n","# Create DataLoaders for train and test datasets\n","train_loader = torch.utils.data.DataLoader(\n","    train_dataset, batch_size=512, shuffle=True, num_workers=2\n",")\n","\n","test_loader = torch.utils.data.DataLoader(\n","    test_dataset, batch_size=512, shuffle=False, num_workers=2\n",")\n","\n","print(\"Num training examples: {}\".format(len(train_dataset)))\n","print(\"Num test examples: {}\".format(len(test_dataset)))\n","\n","\n","# List of class labels\n","classes = [\n","    'T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n","    'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'\n","]"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"urI46YyRSL0I","executionInfo":{"status":"ok","timestamp":1682716390431,"user_tz":420,"elapsed":350,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"bdcdeaf3-bc52-4ace-a389-bbfbdd5ac600"},"execution_count":21,"outputs":[{"output_type":"stream","name":"stdout","text":["Num training examples: 60000\n","Num test examples: 10000\n"]}]},{"cell_type":"markdown","source":["## Visualizing Examples from the FashionMNIST Dataset"],"metadata":{"id":"F_G06d-GWvGw"}},{"cell_type":"code","source":["import matplotlib.pyplot as plt\n","import numpy as np\n","\n","# Function to unnormalize and display an image\n","def imshow(img):\n","    img = img / 2 + 0.5  # Unnormalize\n","    npimg = img.numpy()\n","    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n","    plt.show()\n","\n","# Get a batch of training data\n","dataiter = iter(train_loader)\n","images, labels = next(dataiter)\n","\n","# Display the images in a grid along with their labels\n","imshow(torchvision.utils.make_grid(images[:16]))\n","print(\" -- \".join(f\"{classes[labels[j]]}\" for j in range(8)))\n","print(\" -- \".join(f\"{classes[labels[j]]}\" for j in range(8,16)))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":227},"id":"WvIF1OOuWzqG","executionInfo":{"status":"ok","timestamp":1682716482681,"user_tz":420,"elapsed":2150,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"3a82526a-a63c-4bff-f185-0c76cae1599a"},"execution_count":22,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Sandal -- T-shirt/top -- Trouser -- Bag -- Sandal -- Shirt -- Bag -- Bag\n","Sneaker -- Sandal -- Ankle boot -- Pullover -- Trouser -- Dress -- Dress -- Sneaker\n"]}]},{"cell_type":"markdown","source":["With the dataset loaded and the DataLoader created, we can now train our neural network using the FashionMNIST dataset. Let's modify our previous SimpleNet example to handle 28x28 images and 10 output classes."],"metadata":{"id":"3N2pcw66SKm1"}},{"cell_type":"markdown","source":["### Training on the CPU = Slow!"],"metadata":{"id":"Zq7XH2nwUlA_"}},{"cell_type":"code","source":["import torch.nn.functional as F\n","\n","# Define the neural network for FashionMNIST\n","class FashionMNISTNet(nn.Module):\n","    def __init__(self):\n","        super(FashionMNISTNet, self).__init__()\n","        self.conv1 = nn.Conv2d(1, 16, 3)\n","        self.pool = nn.MaxPool2d(2, 2)\n","        self.conv2 = nn.Conv2d(16, 32, 3)\n","        self.fc1 = nn.Linear(32 * 5 * 5, 128)\n","        self.fc2 = nn.Linear(128, 64)\n","        self.fc3 = nn.Linear(64, 10)\n","\n","    def forward(self, x):\n","        x = self.pool(F.relu(self.conv1(x)))\n","        x = self.pool(F.relu(self.conv2(x)))\n","        x = x.view(-1, 32 * 5 * 5)\n","        x = F.relu(self.fc1(x))\n","        x = F.relu(self.fc2(x))\n","        x = self.fc3(x)\n","        return x\n","\n","# Create an instance of the neural network\n","net = FashionMNISTNet()\n","print(net)\n","\n","# Define the loss function and the optimizer\n","criterion = nn.CrossEntropyLoss()\n","optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)\n","\n","# Train the neural network using the FashionMNIST dataset\n","num_epochs = 5\n","for epoch in range(num_epochs):\n","    running_loss = 0.0\n","    for i, (inputs, labels) in enumerate(train_loader, 0):\n","        # Zero the gradients\n","        optimizer.zero_grad()\n","\n","        # Forward pass\n","        outputs = net(inputs)\n","        \n","        # Compute the loss\n","        loss = criterion(outputs, labels)\n","\n","        # Backward pass\n","        loss.backward()\n","        optimizer.step()\n","\n","        # Update the running loss\n","        running_loss += loss.item()\n","\n","    # Print the average loss for this epoch\n","    avg_loss = running_loss / (i + 1)\n","    print(f\"Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}\")\n","print(\"Training finished.\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":520},"id":"yMrm_5c7RTdM","executionInfo":{"status":"error","timestamp":1682717509674,"user_tz":420,"elapsed":20306,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"f78ff6d3-34bd-4528-b101-2a2377febce3"},"execution_count":23,"outputs":[{"output_type":"stream","name":"stdout","text":["FashionMNISTNet(\n","  (conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1))\n","  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n","  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n","  (fc1): Linear(in_features=800, out_features=128, bias=True)\n","  (fc2): Linear(in_features=128, out_features=64, bias=True)\n","  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",")\n"]},{"output_type":"error","ename":"KeyboardInterrupt","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m<ipython-input-23-9667b4ee5def>\u001b[0m in \u001b[0;36m<cell line: 33>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     44\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m         \u001b[0;31m# Backward pass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     47\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    485\u001b[0m                 \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    486\u001b[0m             )\n\u001b[0;32m--> 487\u001b[0;31m         torch.autograd.backward(\n\u001b[0m\u001b[1;32m    488\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    489\u001b[0m         )\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    198\u001b[0m     \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    199\u001b[0m     \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 200\u001b[0;31m     Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m    201\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    202\u001b[0m         allow_unreachable=True, accumulate_grad=True)  # Calls into the C++ engine to run the backward pass\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]}]},{"cell_type":"markdown","source":["### Training on the GPU = Faster!"],"metadata":{"id":"f_hfcVZsUqhg"}},{"cell_type":"code","source":["import torch.nn.functional as F\n","\n","# Define the neural network for FashionMNIST\n","class FashionMNISTNet(nn.Module):\n","    def __init__(self):\n","        super(FashionMNISTNet, self).__init__()\n","        self.conv1 = nn.Conv2d(1, 16, 3)\n","        self.pool = nn.MaxPool2d(2, 2)\n","        self.conv2 = nn.Conv2d(16, 32, 3)\n","        self.fc1 = nn.Linear(32 * 5 * 5, 128)\n","        self.fc2 = nn.Linear(128, 64)\n","        self.fc3 = nn.Linear(64, 10)\n","\n","    def forward(self, x):\n","        x = self.pool(F.relu(self.conv1(x)))\n","        x = self.pool(F.relu(self.conv2(x)))\n","        x = x.view(-1, 32 * 5 * 5)\n","        x = F.relu(self.fc1(x))\n","        x = F.relu(self.fc2(x))\n","        x = self.fc3(x)\n","        return x\n","\n","# IMPORTANT CODE BELOW\n","# Check if GPU is available\n","device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n","print(\"Using device:\", device)\n","\n","# Create an instance of the neural network\n","net = FashionMNISTNet()\n","print(net)\n","\n","# Move the model to the GPU if available\n","net.to(device)\n","\n","# Define the loss function and the optimizer\n","criterion = nn.CrossEntropyLoss()\n","optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)\n","\n","# Train the neural network using the FashionMNIST dataset\n","num_epochs = 5\n","for epoch in range(num_epochs):\n","    running_loss = 0.0\n","    for i, (inputs, labels) in enumerate(train_loader, 0):\n","\n","        # Move the inputs and labels to the GPU if available\n","        inputs = inputs.to(device)\n","        labels = labels.to(device)\n","\n","        # Zero the gradients\n","        optimizer.zero_grad()\n","\n","        # Forward pass\n","        outputs = net(inputs)\n","        \n","        # Compute the loss\n","        loss = criterion(outputs, labels)\n","\n","        # Backward pass\n","        loss.backward()\n","        optimizer.step()\n","\n","        # Update the running loss\n","        running_loss += loss.item()\n","\n","    # Print the average loss for this epoch\n","    avg_loss = running_loss / (i + 1)\n","    print(f\"Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}\")\n","print(\"Training finished.\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"n4F3cP8tUelq","executionInfo":{"status":"ok","timestamp":1682717719007,"user_tz":420,"elapsed":87295,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"a4cd6798-15c3-4a8e-8fa9-baed1306d3b1"},"execution_count":24,"outputs":[{"output_type":"stream","name":"stdout","text":["Using device: cuda:0\n","FashionMNISTNet(\n","  (conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1))\n","  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n","  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n","  (fc1): Linear(in_features=800, out_features=128, bias=True)\n","  (fc2): Linear(in_features=128, out_features=64, bias=True)\n","  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",")\n","Epoch [1/5], Loss: 1.8958\n","Epoch [2/5], Loss: 0.7033\n","Epoch [3/5], Loss: 0.5873\n","Epoch [4/5], Loss: 0.5203\n","Epoch [5/5], Loss: 0.4676\n","Training finished.\n"]}]},{"cell_type":"markdown","source":["Now that we have trained our neural network, let's evaluate its performance on the test dataset."],"metadata":{"id":"utNlnm2eTUNi"}},{"cell_type":"code","source":["# Test the neural network\n","correct = 0\n","total = 0\n","\n","# Set the model to evaluation mode\n","net.eval()\n","\n","# Disable gradient calculation\n","with torch.no_grad():\n","    for inputs, labels in test_loader:\n","\n","        # Move the inputs and labels to the GPU if available\n","        inputs = inputs.to(device)\n","        labels = labels.to(device)\n","\n","        # Forward pass\n","        outputs = net(inputs)\n","\n","        # Get the predicted class\n","        _, predicted = torch.max(outputs.data, 1)\n","\n","        # Update the total number of samples and correct predictions\n","        total += labels.size(0)\n","        correct += (predicted == labels).sum().item()\n","\n","# Calculate the accuracy\n","accuracy = 100 * correct / total\n","print(f\"Accuracy: {accuracy:.2f}%\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"_XdttlMDSh4-","executionInfo":{"status":"ok","timestamp":1682718003108,"user_tz":420,"elapsed":3573,"user":{"displayName":"Zane Durante","userId":"05159585714773361430"}},"outputId":"989ac9fc-6b98-4702-bef3-97dcf33383c9"},"execution_count":26,"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-26-bf312e143fa7>:20: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n","  _, predicted = torch.max(F.softmax(outputs.data), 1)\n"]},{"output_type":"stream","name":"stdout","text":["Accuracy: 83.19%\n"]}]},{"cell_type":"markdown","source":["Not bad!"],"metadata":{"id":"pP9kK2tNXoze"}},{"cell_type":"code","source":[],"metadata":{"id":"M4j7D84vXppz"},"execution_count":null,"outputs":[]}]}