PyTorch Basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "689745db",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "df91a409",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create tensors \n",
    "x = torch.tensor(1.0,requires_grad=True)\n",
    "w = torch.tensor(2.0,requires_grad=True)\n",
    "b = torch.tensor(3.0,requires_grad=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f9aed982",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a computational graph\n",
    "y = x*w + b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4a200ec9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Compute Gradient\n",
    "y.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e6114a66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(2.)\n",
      "tensor(1.)\n",
      "tensor(1.)\n"
     ]
    }
   ],
   "source": [
    "# Print out the gradients\n",
    "print(x.grad)\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8de8c255",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a tensor of shape (10,3) and (10,2)\n",
    "x = torch.randn(10,3)\n",
    "y = torch.randn(10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "52d29d1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0933, -0.3684, -0.5267],\n",
       "        [ 0.4480, -1.4949,  0.3124],\n",
       "        [-0.4103,  0.2855, -1.2874],\n",
       "        [-0.3632,  0.3125, -0.9794],\n",
       "        [ 1.9856, -0.8502, -0.4797],\n",
       "        [-0.1808, -0.4359, -0.2335],\n",
       "        [ 1.0611,  0.3891, -0.2634],\n",
       "        [-0.8529,  0.1835, -1.2900],\n",
       "        [ 0.3057,  0.3376, -0.6677],\n",
       "        [ 2.8572, -0.3906,  1.5938]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ecf4a45c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.4744,  0.7479],\n",
       "        [ 1.8252, -0.0585],\n",
       "        [-1.1342,  1.0072],\n",
       "        [ 1.0888, -1.2331],\n",
       "        [-1.0294,  1.5570],\n",
       "        [ 0.2660, -0.2905],\n",
       "        [ 0.8143, -0.0652],\n",
       "        [ 2.1063,  0.1571],\n",
       "        [ 2.0930,  0.4943],\n",
       "        [ 0.9028,  0.4970]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "99c28d51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w: Parameter containing:\n",
      "tensor([[-0.5613,  0.2244, -0.4568],\n",
      "        [-0.4456,  0.4453,  0.5101]], requires_grad=True)\n",
      "b: Parameter containing:\n",
      "tensor([ 0.1658, -0.1350], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "# Build a fully connected layer\n",
    "linear = nn.Linear(3,2)\n",
    "print('w:', linear.weight)\n",
    "print('b:', linear.bias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a1f3a8f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the loss function and optimizer\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.SGD(linear.parameters(),lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "80b7a24e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Foward pass\n",
    "pred = linear(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "adbafb5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute loss \n",
    "loss = criterion(pred,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "608a4d49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dl/dw:  None\n",
      "dl/db:  None\n"
     ]
    }
   ],
   "source": [
    "# Print out the gradient\n",
    "print('dl/dw: ', linear.weight.grad)\n",
    "print('dl/db: ', linear.bias.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "95a9302d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1-step gradient descent\n",
    "optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "635d5e1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss after 1 step optimization 2.186506509780884\n"
     ]
    }
   ],
   "source": [
    "pred = linear(x)\n",
    "loss = criterion(pred,y)\n",
    "print('Loss after 1 step optimization', loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0042058a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "x = np.array([[1,2],[3,4]])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6b1a4fdf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert the numpy array to a torch tensor\n",
    "y = torch.from_numpy(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b91bfe24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert the torch tensor to a numpy array\n",
    "z = y.numpy()\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a0a4e8c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████| 170498071/170498071 [00:22<00:00, 7498110.10it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/cifar-10-python.tar.gz to ./data\n"
     ]
    }
   ],
   "source": [
    "# Download and construct CIFAR-10 datasets\n",
    "train_dataset = torchvision.datasets.CIFAR10(root ='./data',\n",
    "train=True,transform=transforms.ToTensor(),download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "85a063c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 32, 32])\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Fetch on dataset pair\n",
    "image,label = train_dataset[0]\n",
    "print(image.size())\n",
    "print(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "8c98f217",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data Loader\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,batch_size=24,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "fc298b52",
   "metadata": {},
   "outputs": [],
   "source": [
    "# When iteration starts, queue and thread start to load data from files\n",
    "data_iter = iter(train_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1ae6e8a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mini-batch images and labels\n",
    "images,label = next(iter(data_iter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "39f45af9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(6)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "images[0]\n",
    "label[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b88880c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}