Basic and Linear Regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "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\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx:  tensor(2.)\n",
      "dw:  tensor(1.)\n",
      "b:  tensor(3.)\n",
      "x:  tensor(1., requires_grad=True)\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Create tensors. As for learning we need to compute the gradient also, so we use tensors  \n",
    "\n",
    "x = torch.tensor(1., requires_grad=True)\n",
    "w = torch.tensor(2., requires_grad=True)\n",
    "b = torch.tensor(3., requires_grad=False)\n",
    "\n",
    "# Build a computational graph.\n",
    "a = w*x\n",
    "y = a + b    # y = 2 * x + 3\n",
    "\n",
    "# Compute gradients.\n",
    "y.backward()\n",
    "\n",
    "# Print out the gradients.\n",
    "print(\"dx: \",x.grad)    # x.grad = 2 \n",
    "print(\"dw: \",w.grad)    # w.grad = 1 \n",
    "print(\"b: \",b)    # b.grad = 1 \n",
    "print(\"x: \", x)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W: Parameter containing:\n",
      "tensor([[ 0.3043, -0.5016, -0.2386],\n",
      "        [ 0.0296,  0.1085, -0.1317]], requires_grad=True)\n",
      "b: Parameter containing:\n",
      "tensor([0.5423, 0.0027], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "input = torch.randn(10, 3)#Note:10 is the number of examples and 3 is no. of feature \n",
    "output = torch.randn(10,2)#no. of output elements is 2(for an example), total examples 10\n",
    "\n",
    "c = nn.Linear(3,2)#takes 3 no. of input feature and gives 2 output feature\n",
    "print(\"W:\",c.weight)\n",
    "print(\"b:\", c.bias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of a is:  tensor([[-0.8575,  1.3380],\n",
      "        [ 0.0211, -0.2638]])\n",
      "The value of c is:  [[-0.85748863  1.3379784 ]\n",
      " [ 0.02113914 -0.2638441 ]]\n",
      "The value of d is:  tensor([[-0.8575,  1.3380],\n",
      "        [ 0.0211, -0.2638]])\n"
     ]
    }
   ],
   "source": [
    "#torch to numpy and Vice versa\n",
    "a = torch.randn(2,2)\n",
    "c = a.numpy()\n",
    "d = torch.from_numpy(c)\n",
    "\n",
    "print(\"The value of a is: \",a)\n",
    "print(\"The value of c is: \",c)\n",
    "print(\"The value of d is: \",d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of X is:  (15, 1)\n",
      "Epoch [10/50], Loss: 4.9680\n",
      "Epoch [20/50], Loss: 0.9578\n",
      "Epoch [30/50], Loss: 0.2997\n",
      "Epoch [40/50], Loss: 0.1916\n",
      "Epoch [50/50], Loss: 0.1739\n"
     ]
    }
   ],
   "source": [
    "#Linear Regression \n",
    "\n",
    "input_size = 1\n",
    "output_size = 1\n",
    "num_epochs = 50\n",
    "learning_rate = 0.001\n",
    "\n",
    "#sample dataset\n",
    "x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], \n",
    "                    [9.779], [6.182], [7.59], [2.167], [7.042], \n",
    "                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)\n",
    "\n",
    "y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], \n",
    "                    [3.366], [2.596], [2.53], [1.221], [2.827], \n",
    "                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)\n",
    "print(\"The shape of X is: \", x_train.shape)\n",
    "\n",
    "model = nn.Linear(input_size, output_size)\n",
    "\n",
    "criterion = nn.MSELoss()#used to set the Loss. Here we have set Mean Square Error Loss\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)#this is used to set the optimizer you use to update the params\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    inputs = torch.from_numpy(x_train)\n",
    "    labels = torch.from_numpy(y_train)\n",
    "    outputs = model(inputs)#input is passed to the data\n",
    "    loss = criterion(outputs, labels)#loss is computed here. Above we have just set the type of loss\n",
    "    optimizer.zero_grad()#It is always important set the gradient as zero before back propagating. \n",
    "    loss.backward()#now all the gradients are computed with respect to loss. In graph if you see it computes the derivative of the parameter which is used to calculate the loss\n",
    "    optimizer.step()#To update the parametes\n",
    "    \n",
    "    if (epoch+1) % 10 == 0:\n",
    "        print ('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#continuation of above, plotting the graph\n",
    "predicted = model(torch.from_numpy(x_train)).detach().numpy()\n",
    "plt.plot(x_train, y_train, 'ro', label='Original data')\n",
    "plt.plot(x_train, predicted, label='Fitted line')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}