Lecture 8 Simple one Conv2D.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor = torch.tensor([0.1, 0.2, 0.3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = tensor.reshape(1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1000, 0.2000, 0.3000]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(in_features=3, out_features=3, bias=True)\n",
    "        self.fc2 = torch.nn.Linear(in_features=3, out_features=1, bias=True)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        print(x)\n",
    "        print(x.shape)\n",
    "        x = self.fc1(x)\n",
    "        print(x)\n",
    "        print(x.shape)\n",
    "        x = self.fc2(x)\n",
    "        print(x)\n",
    "        print(x.shape)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Net()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "par = []\n",
    "for parameter in model.parameters():\n",
    "    par.append(parameter)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.optim import Optimizer\n",
    "class _RequiredParameter(object):\n",
    "    \"\"\"Singleton class representing a required parameter for an Optimizer.\"\"\"\n",
    "    def __repr__(self):\n",
    "        return \"<required parameter>\"\n",
    "\n",
    "required = _RequiredParameter()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "class SGD(Optimizer):\n",
    "    r\"\"\"Implements stochastic gradient descent (optionally with momentum).\n",
    "    Nesterov momentum is based on the formula from\n",
    "    `On the importance of initialization and momentum in deep learning`__.\n",
    "    Args:\n",
    "        params (iterable): iterable of parameters to optimize or dicts defining\n",
    "            parameter groups\n",
    "        lr (float): learning rate\n",
    "        momentum (float, optional): momentum factor (default: 0)\n",
    "        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)\n",
    "        dampening (float, optional): dampening for momentum (default: 0)\n",
    "        nesterov (bool, optional): enables Nesterov momentum (default: False)\n",
    "    Example:\n",
    "        >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)\n",
    "        >>> optimizer.zero_grad()\n",
    "        >>> loss_fn(model(input), target).backward()\n",
    "        >>> optimizer.step()\n",
    "    __ http://www.cs.toronto.edu/%7Ehinton/absps/momentum.pdf\n",
    "    .. note::\n",
    "        The implementation of SGD with Momentum/Nesterov subtly differs from\n",
    "        Sutskever et. al. and implementations in some other frameworks.\n",
    "        Considering the specific case of Momentum, the update can be written as\n",
    "        .. math::\n",
    "                  v = \\rho * v + g \\\\\n",
    "                  p = p - lr * v\n",
    "        where p, g, v and :math:`\\rho` denote the parameters, gradient,\n",
    "        velocity, and momentum respectively.\n",
    "        This is in contrast to Sutskever et. al. and\n",
    "        other frameworks which employ an update of the form\n",
    "        .. math::\n",
    "             v = \\rho * v + lr * g \\\\\n",
    "             p = p - v\n",
    "        The Nesterov version is analogously modified.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, params, lr=required, momentum=0, dampening=0,\n",
    "                 weight_decay=0, nesterov=False):\n",
    "        if lr is not required and lr < 0.0:\n",
    "            raise ValueError(\"Invalid learning rate: {}\".format(lr))\n",
    "        if momentum < 0.0:\n",
    "            raise ValueError(\"Invalid momentum value: {}\".format(momentum))\n",
    "        if weight_decay < 0.0:\n",
    "            raise ValueError(\"Invalid weight_decay value: {}\".format(weight_decay))\n",
    "\n",
    "        defaults = dict(lr=lr, momentum=momentum, dampening=dampening,\n",
    "                        weight_decay=weight_decay, nesterov=nesterov)\n",
    "        if nesterov and (momentum <= 0 or dampening != 0):\n",
    "            raise ValueError(\"Nesterov momentum requires a momentum and zero dampening\")\n",
    "        super(SGD, self).__init__(params, defaults)\n",
    "\n",
    "    def __setstate__(self, state):\n",
    "        super(SGD, self).__setstate__(state)\n",
    "        for group in self.param_groups:\n",
    "            group.setdefault('nesterov', False)\n",
    "\n",
    "    def step(self, closure=None):\n",
    "        \"\"\"Performs a single optimization step.\n",
    "        Arguments:\n",
    "            closure (callable, optional): A closure that reevaluates the model\n",
    "                and returns the loss.\n",
    "        \"\"\"\n",
    "        loss = None\n",
    "        if closure is not None:\n",
    "            loss = closure()\n",
    "\n",
    "        for group in self.param_groups:\n",
    "            weight_decay = group['weight_decay']\n",
    "            momentum = group['momentum']\n",
    "            dampening = group['dampening']\n",
    "            nesterov = group['nesterov']\n",
    "\n",
    "            for p in group['params']:\n",
    "                if p.grad is None:\n",
    "                    continue\n",
    "                d_p = p.grad.data\n",
    "                if weight_decay != 0:\n",
    "                    d_p.add_(weight_decay, p.data)\n",
    "                if momentum != 0:\n",
    "                    param_state = self.state[p]\n",
    "                    if 'momentum_buffer' not in param_state:\n",
    "                        buf = param_state['momentum_buffer'] = torch.clone(d_p).detach()\n",
    "                    else:\n",
    "                        buf = param_state['momentum_buffer']\n",
    "                        buf.mul_(momentum).add_(1 - dampening, d_p)\n",
    "                    if nesterov:\n",
    "                        d_p = d_p.add(momentum, buf)\n",
    "                    else:\n",
    "                        d_p = buf\n",
    "\n",
    "                print('-'*15)\n",
    "                print('Parameter before update:',p)\n",
    "                print('Shape of parameter before update:',p.shape)\n",
    "                print('Gradient:',d_p)\n",
    "                print('Shape of the gradient:',d_p.shape)\n",
    "                print('X:',X)\n",
    "                print('Learning rate:',-group['lr'])\n",
    "                check = p.clone()\n",
    "                p.data.add_(-group['lr'], d_p)\n",
    "                print('Parameter of the tensor after update:', p)\n",
    "                print('Sanity check:', check +(-group['lr']) * d_p)\n",
    "                print('-'*15)\n",
    "\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer_detail = SGD(model.parameters(), lr=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = torch.nn.MSELoss()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.1000, 0.2000, 0.3000]])\n",
      "torch.Size([1, 3])\n",
      "tensor([[ 0.0003, -0.0732,  0.0420]], grad_fn=<AddmmBackward>)\n",
      "torch.Size([1, 3])\n",
      "tensor([[0.0361]], grad_fn=<AddmmBackward>)\n",
      "torch.Size([1, 1])\n"
     ]
    }
   ],
   "source": [
    "output = model(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loss = output - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = criterion(1, output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer_detail.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------\n",
      "Parameter before update: Parameter containing:\n",
      "tensor([[-0.2920, -0.4200, -0.3449],\n",
      "        [ 0.0455,  0.4253, -0.0052],\n",
      "        [ 0.5471, -0.0541, -0.0723]], requires_grad=True)\n",
      "Shape of parameter before update: torch.Size([3, 3])\n",
      "Gradient: tensor([[-0.0405, -0.0810, -0.1215],\n",
      "        [ 0.0795,  0.1591,  0.2386],\n",
      "        [ 0.0164,  0.0327,  0.0491]])\n",
      "Shape of the gradient: torch.Size([3, 3])\n",
      "X: tensor([[0.1000, 0.2000, 0.3000]])\n",
      "Learning rate: -1\n",
      "Parameter of the tensor after update: Parameter containing:\n",
      "tensor([[-0.2515, -0.3390, -0.2234],\n",
      "        [-0.0340,  0.2662, -0.2438],\n",
      "        [ 0.5308, -0.0868, -0.1214]], requires_grad=True)\n",
      "Sanity check: tensor([[-0.2515, -0.3390, -0.2234],\n",
      "        [-0.0340,  0.2662, -0.2438],\n",
      "        [ 0.5308, -0.0868, -0.1214]], grad_fn=<AddBackward0>)\n",
      "---------------\n",
      "---------------\n",
      "Parameter before update: Parameter containing:\n",
      "tensor([ 0.2170, -0.1612,  0.0198], requires_grad=True)\n",
      "Shape of parameter before update: torch.Size([3])\n",
      "Gradient: tensor([-0.4051,  0.7953,  0.1637])\n",
      "Shape of the gradient: torch.Size([3])\n",
      "X: tensor([[0.1000, 0.2000, 0.3000]])\n",
      "Learning rate: -1\n",
      "Parameter of the tensor after update: Parameter containing:\n",
      "tensor([ 0.6221, -0.9565, -0.1439], requires_grad=True)\n",
      "Sanity check: tensor([ 0.6221, -0.9565, -0.1439], grad_fn=<AddBackward0>)\n",
      "---------------\n",
      "---------------\n",
      "Parameter before update: Parameter containing:\n",
      "tensor([[ 0.2101, -0.4125, -0.0849]], requires_grad=True)\n",
      "Shape of parameter before update: torch.Size([1, 3])\n",
      "Gradient: tensor([[-0.0006,  0.1411, -0.0809]])\n",
      "Shape of the gradient: torch.Size([1, 3])\n",
      "X: tensor([[0.1000, 0.2000, 0.3000]])\n",
      "Learning rate: -1\n",
      "Parameter of the tensor after update: Parameter containing:\n",
      "tensor([[ 0.2108, -0.5536, -0.0040]], requires_grad=True)\n",
      "Sanity check: tensor([[ 0.2108, -0.5536, -0.0040]], grad_fn=<AddBackward0>)\n",
      "---------------\n",
      "---------------\n",
      "Parameter before update: Parameter containing:\n",
      "tensor([0.0094], requires_grad=True)\n",
      "Shape of parameter before update: torch.Size([1])\n",
      "Gradient: tensor([-1.9278])\n",
      "Shape of the gradient: torch.Size([1])\n",
      "X: tensor([[0.1000, 0.2000, 0.3000]])\n",
      "Learning rate: -1\n",
      "Parameter of the tensor after update: Parameter containing:\n",
      "tensor([1.9372], requires_grad=True)\n",
      "Sanity check: tensor([1.9372], grad_fn=<AddBackward0>)\n",
      "---------------\n"
     ]
    }
   ],
   "source": [
    "optimizer_detail.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculations\n",
    "\n",
    "First we have to take derivative of MSELoss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.9278]], grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(output-1)*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------\n",
    "Parameter before update: Parameter containing:\n",
    "tensor([0.0094], requires_grad=True)\n",
    "Shape of parameter before update: torch.Size([1])\n",
    "Gradient: tensor([-1.9278])\n",
    "Shape of the gradient: torch.Size([1])\n",
    "X: tensor([[0.1000, 0.2000, 0.3000]])\n",
    "Learning rate: -1\n",
    "Parameter of the tensor after update: Parameter containing:\n",
    "tensor([1.9372], requires_grad=True)\n",
    "Sanity check: tensor([1.9372], grad_fn=<AddBackward0>)\n",
    "---------------\n",
    "```\n",
    "\n",
    "We are dealing with optimization of  bias in the 2nd layer which is equal to wx+b w.r.t to b whtich is 1.\n",
    "\n",
    "Using chain rule f'(loss(wx+b)) = f'(loss(wx+b)) * f'(wx+b) = [-1.9278] * 1 = [-1.9278]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.9278]], grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(output-1)*2*1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are dealing with optimization of weight in the 2nd layer which is equal to wx+b w.r.t to w whtich is x.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.0006,  0.1411, -0.0810])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.tensor([-1.9278]) * torch.tensor([ 0.0003, -0.0732,  0.0420])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are dealing with optimization of bias in the 1st layer which is equal to wx+b w.r.t to b whtich is 1. And using chain rule we multiply derivative of loss function and derivative of 2nd layer wx+b w.r.t. x which w and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.4050,  0.7952,  0.1637])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.tensor([-1.9278]) * torch.tensor([ 0.2101, -0.4125, -0.0849])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are dealing with optimization of weight in the 1st layer which is equal to wx+b w.r.t to w whtich is x. And using chain rule we multiply derivative of loss function and derivative of 2nd layer wx+b w.r.t. x which w and x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0405, -0.0810, -0.1215],\n",
       "        [ 0.0795,  0.1590,  0.2386],\n",
       "        [ 0.0164,  0.0327,  0.0491]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(torch.tensor([ 0.2101, -0.4125, -0.0849]) *\n",
    " torch.tensor([-1.9278])).reshape(3,1).matmul(torch.tensor([0.1000, 0.2000, 0.3000]).reshape(1,3))"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}