pytorch_5_building_the_neural_network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a9ab9655",
   "metadata": {},
   "source": [
    "# Build the Neural Network\n",
    "\n",
    "Neural networks consists of interconnected layers or components that process information. The `torch.nn` namespace supplies all the essential elements for creating a custom neural network. In PyTorch, every module is a subclass of nn.Module. A neural network is itself a module made up of other modules(layers), allowing for the simple construction and organization of intricate architectures.\n",
    "\n",
    "In the subsequenct segments, we will develop a neural network for categorizing images within the FashionMNIST dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fd9fc8b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "# Importing the necessary building blocks to create and work with neural network\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d5e747a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(f\"Using {device} device\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "afba4992",
   "metadata": {},
   "outputs": [],
   "source": [
    "# DEFINE THE CLASS\n",
    "\n",
    "# We define our neural network by subclassing `nn.Module`, and initialize the neural network layers in __init__. Every `nn.Module` subclass implements the operations on input data in the `forward` method\n",
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28*28, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 10),\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9015e63f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NeuralNetwork(\n",
      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  (linear_relu_stack): Sequential(\n",
      "    (0): Linear(in_features=784, out_features=512, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=512, out_features=512, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=512, out_features=10, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# We create an instance of `NeuralNetwork`, and move it to the `device`, and print its structure\n",
    "model = NeuralNetwork().to(device)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "264ccb47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted class: tensor([7], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "# To use the model, we pass it the input data. This executes the model's `forward`, along with some background operations.\n",
    "# Do not call `model.forward()` directly.\n",
    "\n",
    "# Calling the model on the input returns a 2-dimensional tensor with dim = 0 corresponding to each output of 10 raw predicted values for each class, and dim = 1 corresponding to the individual values of each output. We get the prediction probabilities by passing it through an instance of the `nn.Softmax` module.\n",
    "X = torch.rand(1, 28, 28, device = device)\n",
    "logits = model(X)\n",
    "pred_probab = nn.Softmax(dim = 1)(logits)\n",
    "y_pred = pred_probab.argmax(1)\n",
    "print(f\"Predicted class: {y_pred}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cd21594e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "# MODEL LAYERS\n",
    "\n",
    "# Let's break down the layrs in the FashionMNIST model. To illustrate it, we will take a sample minibatch of 3 images of size 28x28 and see what happens to it as we pass it through the network\n",
    "input_image = torch.rand(3, 28, 28)\n",
    "print(input_image.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "da173d71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 784])\n"
     ]
    }
   ],
   "source": [
    "# nn.Flatten\n",
    "\n",
    "# We initialize the `nn.Flatten` layer to convert each 2D 28x28 image into a contiguous array of 784 pixel values (the minibatch dimension (at dim = 0) is maintained)\n",
    "flatten = nn.Flatten()\n",
    "flat_image = flatten(input_image)\n",
    "print(flat_image.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "57b8be25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 20])\n"
     ]
    }
   ],
   "source": [
    "# nn.Linear\n",
    "\n",
    "# The linear layer is a module that applies a linear transformation on the input usin its stored weights and biases\n",
    "layer1 = nn.Linear(in_features = 28*28, out_features = 20)\n",
    "hidden1 = layer1(flat_image)\n",
    "print(hidden1.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "41c9bad9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before ReLU: tensor([[ 0.3235, -0.1688,  0.6223, -0.2024,  0.0145,  0.0499,  0.0394,  0.2611,\n",
      "          0.0346, -0.1341, -0.7167, -0.0926,  0.1514, -0.3075, -0.0142,  0.2741,\n",
      "          0.0010,  0.2832, -0.4210, -0.1214],\n",
      "        [ 0.5129,  0.1634,  0.4923, -0.2584,  0.0060,  0.0848, -0.1998,  0.0027,\n",
      "          0.1571, -0.1094, -0.8463, -0.2198, -0.1086, -0.4119,  0.2210,  0.4198,\n",
      "         -0.0268,  0.6057, -0.1111, -0.2832],\n",
      "        [ 0.1763,  0.1407,  0.6262, -0.0722,  0.2622, -0.2901, -0.1397,  0.1571,\n",
      "         -0.1506, -0.4649, -0.8416, -0.1729,  0.2107, -0.2799,  0.5045,  0.1497,\n",
      "          0.0786,  0.5266, -0.3103,  0.1906]], grad_fn=<AddmmBackward0>)\n",
      "\n",
      "\n",
      "After ReLU: tensor([[0.3235, 0.0000, 0.6223, 0.0000, 0.0145, 0.0499, 0.0394, 0.2611, 0.0346,\n",
      "         0.0000, 0.0000, 0.0000, 0.1514, 0.0000, 0.0000, 0.2741, 0.0010, 0.2832,\n",
      "         0.0000, 0.0000],\n",
      "        [0.5129, 0.1634, 0.4923, 0.0000, 0.0060, 0.0848, 0.0000, 0.0027, 0.1571,\n",
      "         0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.2210, 0.4198, 0.0000, 0.6057,\n",
      "         0.0000, 0.0000],\n",
      "        [0.1763, 0.1407, 0.6262, 0.0000, 0.2622, 0.0000, 0.0000, 0.1571, 0.0000,\n",
      "         0.0000, 0.0000, 0.0000, 0.2107, 0.0000, 0.5045, 0.1497, 0.0786, 0.5266,\n",
      "         0.0000, 0.1906]], grad_fn=<ReluBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# nn.ReLU\n",
    "\n",
    "# Non-linear activation are what create the complex mappings between the model's inputs and outputs. They are applied after linear transformations to introduce nonlinearity, helping neural networks learn a wide variety of phenomena\n",
    "\n",
    "# In this model, use nn.ReLU between our linear layers, but there's other activations to introduce non-linearity in your model\n",
    "print(f\"Before ReLU: {hidden1}\\n\\n\")\n",
    "hidden1 = nn.ReLU()(hidden1)\n",
    "print(f\"After ReLU: {hidden1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ef0a067f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nn.Sequential\n",
    "\n",
    "# `nn.Sequential` is an ordered container of modules. The data is passedthrough all the modules in the same order as defined. You can use sequential containers to put together a quick network like `seq_modules`\n",
    "seq_modules = nn.Sequential(\n",
    "    flatten,\n",
    "    layer1,\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(20,10),\n",
    ")\n",
    "input_image = torch.rand(3,28,28)\n",
    "logits = seq_modules(input_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "20257bc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nn.Softmax\n",
    "\n",
    "#The last linear layer of the neural network returns logits raw values in [-inf, inf] which are passed to the nn.Softmax module.\n",
    "# The logits are scaled to values [0,1] representing the model's predicted probabilities for each class.\n",
    "# `dim` parameter indicates the dimension along which the values must sum to 1.\n",
    "softmax = nn.Softmax(dim=1)\n",
    "pred_probab = softmax(logits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bc3f136b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model structure: NeuralNetwork(\n",
      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  (linear_relu_stack): Sequential(\n",
      "    (0): Linear(in_features=784, out_features=512, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=512, out_features=512, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=512, out_features=10, bias=True)\n",
      "  )\n",
      ")\n",
      "\n",
      "\n",
      "Layer: linear_relu_stack.0.weight | Size: torch.Size([512, 784]) | Values : tensor([[-0.0215,  0.0169, -0.0085,  ...,  0.0133,  0.0209, -0.0032],\n",
      "        [-0.0245,  0.0083, -0.0341,  ...,  0.0233,  0.0300,  0.0186]],\n",
      "       device='cuda:0', grad_fn=<SliceBackward0>)\n",
      "\n",
      "Layer: linear_relu_stack.0.bias | Size: torch.Size([512]) | Values : tensor([-0.0242,  0.0079], device='cuda:0', grad_fn=<SliceBackward0>)\n",
      "\n",
      "Layer: linear_relu_stack.2.weight | Size: torch.Size([512, 512]) | Values : tensor([[ 0.0038, -0.0028, -0.0295,  ..., -0.0390,  0.0376,  0.0193],\n",
      "        [ 0.0395, -0.0095,  0.0047,  ...,  0.0318, -0.0205,  0.0034]],\n",
      "       device='cuda:0', grad_fn=<SliceBackward0>)\n",
      "\n",
      "Layer: linear_relu_stack.2.bias | Size: torch.Size([512]) | Values : tensor([ 0.0303, -0.0307], device='cuda:0', grad_fn=<SliceBackward0>)\n",
      "\n",
      "Layer: linear_relu_stack.4.weight | Size: torch.Size([10, 512]) | Values : tensor([[ 0.0303, -0.0313,  0.0103,  ..., -0.0439,  0.0211,  0.0259],\n",
      "        [-0.0116,  0.0165, -0.0290,  ...,  0.0242,  0.0127, -0.0050]],\n",
      "       device='cuda:0', grad_fn=<SliceBackward0>)\n",
      "\n",
      "Layer: linear_relu_stack.4.bias | Size: torch.Size([10]) | Values : tensor([ 0.0234, -0.0398], device='cuda:0', grad_fn=<SliceBackward0>)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# MODEL PARAMETERS\n",
    "\n",
    "# Many layers inside a neural network are parameterized, i.e. have associated weights and biases that are optimized durin training.\n",
    "# Subclassing nn.Module automatically tracks all fields defined inside your model bject, and makes all parameters accessible using your model's `parameters()` or `named_parameters()` methods.\n",
    "# In this example, we iterate over each parameter, and print its size and a preview of its values\n",
    "print(f\"Model structure: {model}\\n\\n\")\n",
    "for name, param in model.named_parameters():\n",
    "    print(f\"Layer: {name} | Size: {param.size()} | Values : {param[:2]}\\n\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}