Extra_Chapter_Hook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "v3RSRJUuHiKa",
        "m_uW0KnPSDjH"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JimEverest/CAM/blob/main/Extra_Chapter_Hook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Hook\n",
        "\n",
        "\n",
        "Hook 是 PyTorch 中一个十分有用的特性。利用它，我们可以不必改变网络输入输出的结构，方便地获取、改变网络中间层变量的值和梯度。这个功能被广泛用于可视化神经网络中间层的 feature、gradient，从而诊断神经网络中可能出现的问题，分析网络有效性。本文将结合代码，由浅入深地介绍 pytorch 中 hook 的用法。\n",
        "\n",
        "```\n",
        "1.Hook for Tensors ：针对 Tensor 的 hook\n",
        "\n",
        "2.Hook for Modules：针对例如 nn.Conv2dnn.Linear等网络模块的 hook\n",
        "```\n"
      ],
      "metadata": {
        "id": "mUenQXTPHeyw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How to retain gradient for non-leaf nodes?"
      ],
      "metadata": {
        "id": "v3RSRJUuHiKa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "ID__6jayF19l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "x = torch.Tensor([0, 1, 2, 3]).requires_grad_()\n",
        "y = torch.Tensor([4, 5, 6, 7]).requires_grad_()\n",
        "w = torch.Tensor([1, 2, 3, 4]).requires_grad_()\n",
        "z = x+y\n",
        "# z.retain_grad()\n",
        "o = w.matmul(z)\n",
        "print(o)\n",
        "o.backward()\n",
        "# o.retain_grad()"
      ],
      "metadata": {
        "id": "SapBEAforL7-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('x.requires_grad:', x.requires_grad) # True\n",
        "print('y.requires_grad:', y.requires_grad) # True\n",
        "print('z.requires_grad:', z.requires_grad) # True\n",
        "print('w.requires_grad:', w.requires_grad) # True\n",
        "print('o.requires_grad:', o.requires_grad) # True"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zjC6iMslrL2Q",
        "outputId": "3cd5210c-5542-43dd-b556-1fc7ab629edc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x.requires_grad: True\n",
            "y.requires_grad: True\n",
            "z.requires_grad: True\n",
            "w.requires_grad: True\n",
            "o.requires_grad: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "由于 z 和 o 为中间变量（并非直接指定数值的变量，而是由别的变量计算得到的变量），它们虽然 requires_grad 的参数都是 True，\n",
        "但是反向传播后，它们的梯度并没有保存下来，而是直接删除了，因此是 None。\n",
        "<br>"
      ],
      "metadata": {
        "id": "QS9F83PNGCO9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('x.grad:', x.grad) # tensor([1., 2., 3., 4.])\n",
        "print('y.grad:', y.grad) # tensor([1., 2., 3., 4.])\n",
        "print('w.grad:', w.grad) # tensor([ 4.,  6.,  8., 10.])\n",
        "print('z.grad:', z.grad) # None\n",
        "print('o.grad:', o.grad) # None"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W3DbTQ9_rLwY",
        "outputId": "e1770369-c4f1-4a80-f2f1-c18811d0263b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x.grad: tensor([1., 2., 3., 4.])\n",
            "y.grad: tensor([1., 2., 3., 4.])\n",
            "w.grad: tensor([ 4.,  6.,  8., 10.])\n",
            "z.grad: None\n",
            "o.grad: None\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-10-92c914bf4f6d>:4: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at aten/src/ATen/core/TensorBody.h:480.)\n",
            "  print('z.grad:', z.grad) # None\n",
            "<ipython-input-10-92c914bf4f6d>:5: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at aten/src/ATen/core/TensorBody.h:480.)\n",
            "  print('o.grad:', o.grad) # None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "如果想在反向传播之后保留它们的梯度，则需要特殊指定：把上面代码中的`z.retain_grad() 和 o.retain_grad`的注释去掉，可以得到它们对应的梯度，"
      ],
      "metadata": {
        "id": "OdnXh2TjH0Mp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = torch.Tensor([0, 1, 2, 3]).requires_grad_()\n",
        "y = torch.Tensor([4, 5, 6, 7]).requires_grad_()\n",
        "w = torch.Tensor([1, 2, 3, 4]).requires_grad_()\n",
        "z = x+y\n",
        "z.retain_grad()\n",
        "o = w.matmul(z)\n",
        "print(o)\n",
        "o.backward()\n",
        "o.retain_grad()\n",
        "\n",
        "print('x.requires_grad:', x.requires_grad) # True\n",
        "print('y.requires_grad:', y.requires_grad) # True\n",
        "print('z.requires_grad:', z.requires_grad) # True\n",
        "print('w.requires_grad:', w.requires_grad) # True\n",
        "print('o.requires_grad:', o.requires_grad) # True"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IexiWzokHsqy",
        "outputId": "ee909926-664e-49c3-bb66-fce656c5d8ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(80., grad_fn=<DotBackward0>)\n",
            "x.requires_grad: True\n",
            "y.requires_grad: True\n",
            "z.requires_grad: True\n",
            "w.requires_grad: True\n",
            "o.requires_grad: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Hook for Tensors\n",
        "\n",
        "> 但是，这种加 retain_grad() 的方案会增加内存占用，并不是个好办法，对此的一种替代方案，就是用 hook 保存中间变量的梯度。\n",
        "\n",
        ">对于中间变量z，hook 的使用方式为：`z.register_hook(hook_fn)`，其中 hook_fn为一个用户自定义的函数，其签名为：\n",
        "```\n",
        "hook_fn(grad) \n",
        "  return Tensor or None\n",
        "```\n",
        "\n",
        "<b>输入</b>为变量 <font color=\"red\">z 的梯度</font> ，\n",
        "\n",
        "<b>输出</b>为一个 <font color=\"red\">Tensor</font> 或者是 None （None 一般用于直接打印梯度）。\n",
        "\n",
        "反向传播时，梯度传播到变量 z，再继续向前传播之前，将会传入 <font color=\"red\">hook_fn</font>。\n",
        "\n",
        "如果hook_fn的返回值是 None，那么梯度将不改变，继续向前传播，仅仅是打印梯度："
      ],
      "metadata": {
        "id": "ElflhAgCH7P5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "x = torch.Tensor([0, 1, 2, 3]).requires_grad_()\n",
        "y = torch.Tensor([4, 5, 6, 7]).requires_grad_()\n",
        "w = torch.Tensor([1, 2, 3, 4]).requires_grad_()\n",
        "z = x+y\n",
        "\n",
        "# ===================\n",
        "# 1. define hook function\n",
        "def hook_fn(grad):\n",
        "    print(grad)\n",
        "\n",
        "# 2. find the injection Point to hook up. (a non-leaf node tensor)\n",
        "z.register_hook(hook_fn)\n",
        "# ===================\n",
        "\n",
        "o = w.matmul(z)\n",
        "\n",
        "print('=====Start backprop=====')\n",
        "o.backward() # tensor([1., 2., 3., 4.])\n",
        "print('=====End backprop=====')\n",
        "\n",
        "print('x.grad:', x.grad) # x.grad: tensor([1., 2., 3., 4.])\n",
        "print('y.grad:', y.grad) # y.grad: tensor([1., 2., 3., 4.])\n",
        "print('w.grad:', w.grad) # w.grad: tensor([ 4.,  6.,  8., 10.])\n",
        "print('z.grad:', z.grad) # z.grad: None\n",
        "\n",
        "# z绑定了hook_fn后，梯度反向传播时将会打印出 o 对 z 的偏导，和上文中z.retain_grad()方法得到的 z 的偏导一致。\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i0NlxHxfH2YA",
        "outputId": "b0510c89-f022-4585-8052-390e6b2bfc64"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=====Start backprop=====\n",
            "tensor([1., 2., 3., 4.])\n",
            "=====End backprop=====\n",
            "x.grad: tensor([1., 2., 3., 4.])\n",
            "y.grad: tensor([1., 2., 3., 4.])\n",
            "w.grad: tensor([ 4.,  6.,  8., 10.])\n",
            "z.grad: None\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-12-588a09eb5e96>:26: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at aten/src/ATen/core/TensorBody.h:480.)\n",
            "  print('z.grad:', z.grad)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "如果 hook_fn的返回值是 Tensor 类型，则该 Tensor 将取代 z 原有的梯度，向前传播。"
      ],
      "metadata": {
        "id": "U15oTxYgPnBo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "x = torch.Tensor([0, 1, 2, 3]).requires_grad_()\n",
        "y = torch.Tensor([4, 5, 6, 7]).requires_grad_()\n",
        "w = torch.Tensor([1, 2, 3, 4]).requires_grad_()\n",
        "z = x + y\n",
        "\n",
        "\n",
        "# ===================\n",
        "def hook_fn(grad):\n",
        "    g = 2 * grad\n",
        "    print(g)\n",
        "    return g\n",
        "\n",
        "\n",
        "z.register_hook(hook_fn)\n",
        "# ===================\n",
        "\n",
        "o = w.matmul(z)\n",
        "\n",
        "print('=====Start backprop=====')\n",
        "o.backward() # tensor([2., 4., 6., 8.])\n",
        "print('=====End backprop=====')\n",
        "\n",
        "print('x.grad:', x.grad) # x.grad: tensor([2., 4., 6., 8.])\n",
        "print('y.grad:', y.grad) # y.grad: tensor([2., 4., 6., 8.])\n",
        "print('w.grad:', w.grad) # w.grad: tensor([ 4.,  6.,  8., 10.])\n",
        "print('z.grad:', z.grad) # z.grad: None\n",
        "\n",
        "#  z 的梯度变为两倍后，受其影响，x和y的梯度也都变成了原来的两倍。"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kXUJ3_x-H2Vd",
        "outputId": "f8c0ad91-3eb4-4db8-c23b-59dc693974e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=====Start backprop=====\n",
            "tensor([2., 4., 6., 8.])\n",
            "=====End backprop=====\n",
            "x.grad: tensor([2., 4., 6., 8.])\n",
            "y.grad: tensor([2., 4., 6., 8.])\n",
            "w.grad: tensor([ 4.,  6.,  8., 10.])\n",
            "z.grad: None\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-13-5902f6a93dfb>:28: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at aten/src/ATen/core/TensorBody.h:480.)\n",
            "  print('z.grad:', z.grad)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Hook for Modules\n",
        "> 最常用的 hook 使用场景一般是针对神经网络模块的"
      ],
      "metadata": {
        "id": "7ZWymRQvQg8d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "module 不像上一节中的 Tensor，拥有显式的变量名可以直接访问\n",
        "\n",
        "而是被封装在神经网络中间。我们通常只能获得网络整体的输入和输出，对于夹在网络中间的模块，<br/>我们不但很难得知它输入/输出的梯度，甚至连它输入输出的数值都无法获得。\n",
        "\n",
        "除非设计网络时，在 forward 函数的返回值中包含中间 module 的输出，\n",
        "\n",
        "或者用很麻烦的办法，把网络按照 module 的名称拆分再组合，让中间层提取的 feature 暴露出来。\n",
        "\n",
        "<hr>\n",
        "为了解决这个麻烦，PyTorch 设计了两种 hook：\n",
        "\n",
        "`register_forward_hook` 和`register_backward_hook`\n",
        "\n",
        "分别用来获取正/反向传播时，中间层模块输入和输出的 feature/gradient，大大降低了获取模型内部信息流的难度。\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "BdxAE2BHREWc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### register forward hook\n",
        "\n",
        "`register_forward_hook`的作用是获取前向传播过程中，各个网络模块的输入和输出。\n",
        "\n",
        "对于模块module，其使用方式为：<font color=\"red\">`module.register_forward_hook(hook_fn)`</font> 。其中 hook_fn的签名为：\n",
        "\n",
        "```\n",
        "hook_fn(module, input, output)\n",
        "  return None\n",
        "```\n",
        "它的输入变量分别为：`模块`，`模块的输入`，`模块的输出`，\n",
        "\n",
        "和对 Tensor 的 hook 不同，forward hook 不返回任何值，\n",
        "\n",
        "也就是说不能用它来修改输入或者输出的值，但借助这个 hook，我们可以<font color=\"red\">`方便地用预训练的神经网络提取特征，而不用改变预训练网络的结构`。</font>\n",
        "\n",
        "下面提供一段示例代码："
      ],
      "metadata": {
        "id": "m_uW0KnPSDjH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "\n",
        "class Model(nn.Module):\n",
        "    def __init__(self): # fc1 --> relu --> fc2\n",
        "        super(Model, self).__init__()\n",
        "        self.fc1 = nn.Linear(3, 4)\n",
        "        self.relu1 = nn.ReLU()\n",
        "        self.fc2 = nn.Linear(4, 1)\n",
        "        self.initialize()           \n",
        "    \n",
        "    # 为了方便验证，指定特殊的weight和bias\n",
        "    def initialize(self):\n",
        "        with torch.no_grad():\n",
        "            self.fc1.weight = torch.nn.Parameter(\n",
        "                torch.Tensor([[1., 2., 3.],\n",
        "                        [-4., -5., -6.],\n",
        "                        [7., 8., 9.],\n",
        "                        [-10., -11., -12.]]))\n",
        "\n",
        "            self.fc1.bias = torch.nn.Parameter(torch.Tensor([1.0, 2.0, 3.0, 4.0]))\n",
        "            self.fc2.weight = torch.nn.Parameter(torch.Tensor([[1.0, 2.0, 3.0, 4.0]]))\n",
        "            self.fc2.bias = torch.nn.Parameter(torch.Tensor([1.0]))\n",
        "\n",
        "    def forward(self, x):\n",
        "        o = self.fc1(x)\n",
        "        o = self.relu1(o)\n",
        "        o = self.fc2(o)\n",
        "        return o\n",
        "\n",
        "\n",
        "# 全局变量，用于存储中间层的 feature\n",
        "total_feat_out = []\n",
        "total_feat_in = []\n",
        "\n",
        "# 定义 forward hook function\n",
        "def hook_fn_forward(module, input, output):\n",
        "    print(module) # 用于区分模块\n",
        "    print('input', input) # 首先打印出来\n",
        "    print('output', output)\n",
        "    total_feat_out.append(output) # 然后分别存入全局 list 中\n",
        "    total_feat_in.append(input)\n",
        "\n",
        "\n",
        "model = Model()\n",
        "\n",
        "modules = model.named_children()   #[   ('fc1', Linear(in_features=3, out_features=4, bias=True) ),     ('relu1', ReLU() ),     ('fc2', Linear(in_features=4, out_features=1, bias=True) )     ]\n",
        "\n",
        "for name, module in modules:\n",
        "    module.register_forward_hook(hook_fn_forward)\n",
        "    # module.register_backward_hook(hook_fn_backward)\n",
        "\n",
        "# 注意下面代码中 x 的维度，对于linear module，输入一定是大于等于二维的\n",
        "# （第一维是 batch size）。在 forward hook 中看不出来，但是 backward hook 中， 得到的梯度完全不对。\n",
        "\n",
        "x = torch.Tensor([[1.0, 1.0, 1.0]]).requires_grad_() # torch.Size([1, 3])\n",
        "o = model(x)\n",
        "o.backward()\n",
        "\n",
        "print('==========Saved inputs and outputs==========')\n",
        "for idx in range(len(total_feat_in)):\n",
        "    print('input: ', total_feat_in[idx])\n",
        "    print('output: ', total_feat_out[idx])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O1jQgePfSDLH",
        "outputId": "9202f3fe-5bd5-4f65-d2cb-d95957160f25"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Linear(in_features=3, out_features=4, bias=True)\n",
            "input (tensor([[1., 1., 1.]], requires_grad=True),)\n",
            "output tensor([[  7., -13.,  27., -29.]], grad_fn=<AddmmBackward0>)\n",
            "ReLU()\n",
            "input (tensor([[  7., -13.,  27., -29.]], grad_fn=<AddmmBackward0>),)\n",
            "output tensor([[ 7.,  0., 27.,  0.]], grad_fn=<ReluBackward0>)\n",
            "Linear(in_features=4, out_features=1, bias=True)\n",
            "input (tensor([[ 7.,  0., 27.,  0.]], grad_fn=<ReluBackward0>),)\n",
            "output tensor([[89.]], grad_fn=<AddmmBackward0>)\n",
            "==========Saved inputs and outputs==========\n",
            "input:  (tensor([[1., 1., 1.]], requires_grad=True),)\n",
            "output:  tensor([[  7., -13.,  27., -29.]], grad_fn=<AddmmBackward0>)\n",
            "input:  (tensor([[  7., -13.,  27., -29.]], grad_fn=<AddmmBackward0>),)\n",
            "output:  tensor([[ 7.,  0., 27.,  0.]], grad_fn=<ReluBackward0>)\n",
            "input:  (tensor([[ 7.,  0., 27.,  0.]], grad_fn=<ReluBackward0>),)\n",
            "output:  tensor([[89.]], grad_fn=<AddmmBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![b50a00e68ecefe1570ef6bfd4a090b3.jpg](data:image/jpeg;base64,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)"
      ],
      "metadata": {
        "id": "Gzo8JdcPtawB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## register backward hook\n",
        "\n",
        "`register_backward_hook` 的作用是获取神经网络反向传播过程中，各个模块输入端和输出端的梯度值。对于模块 module，其使用方式为：module.register_backward_hook(hook_fn) 。其中hook_fn的函数签名为：\n",
        "```\n",
        "hook_fn(module, grad_input, grad_output) \n",
        "    return Tensor or None\n",
        "```\n",
        "输入变量分别为：`模块`，`模块输入端的梯度`，`模块输出端的梯度`。\n",
        "> 需要注意的是，<font color=\"red\">这里的输入端和输出端，是站在前向传播的角度的，而不是反向传播的角度</font>。\n",
        "\n",
        "例如线性模块：`o=W*x+b`，其输入端为 W，x 和 b，输出端为 o。\n",
        "\n",
        "\n",
        "如果模块有多个输入或者输出的话，grad_input和grad_output可以是 `tuple` 类型。\n",
        "\n",
        "对于线性模块：`o=W*x+b` ，它的输入端包括了W、x 和 b 三部分，因此 grad_input 就是一个包含三个元素的 `tuple`。\n",
        "\n",
        "这里注意和 forward hook 的不同：\n",
        "\n",
        "1. 在 forward hook 中，input 是 x，而不包括 W 和 b。\n",
        "\n",
        "2. 返回 Tensor 或者 None， \n",
        "  > backward hook 函数不能直接改变它的输入变量，但是可以返回新的 grad_input，反向传播到它上一个模块。\n"
      ],
      "metadata": {
        "id": "wWqDuxXTtlVG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Backward\n",
        "\n",
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "\n",
        "class Model(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Model, self).__init__()\n",
        "        self.fc1 = nn.Linear(3, 4)\n",
        "        self.relu1 = nn.ReLU()\n",
        "        self.fc2 = nn.Linear(4, 1)\n",
        "        self.initialize()\n",
        "\n",
        "    def initialize(self):\n",
        "        with torch.no_grad():\n",
        "            self.fc1.weight = torch.nn.Parameter(\n",
        "                torch.Tensor([[1., 2., 3.],\n",
        "                              [-4., -5., -6.],\n",
        "                              [7., 8., 9.],\n",
        "                              [-10., -11., -12.]]))\n",
        "\n",
        "            self.fc1.bias = torch.nn.Parameter(torch.Tensor([1.0, 2.0, 3.0, 4.0]))\n",
        "            self.fc2.weight = torch.nn.Parameter(torch.Tensor([[1.0, 2.0, 3.0, 4.0]]))\n",
        "            self.fc2.bias = torch.nn.Parameter(torch.Tensor([1.0]))\n",
        "\n",
        "    def forward(self, x):\n",
        "        o = self.fc1(x)\n",
        "        o = self.relu1(o)\n",
        "        o = self.fc2(o)\n",
        "        return o\n",
        "\n",
        "\n",
        "total_grad_out = []\n",
        "total_grad_in = []\n",
        "\n",
        "\n",
        "def hook_fn_backward(module, grad_input, grad_output):\n",
        "    print(module) # 为了区分模块\n",
        "    # 为了符合反向传播的顺序，我们先打印 grad_output\n",
        "    print('grad_output', grad_output) \n",
        "    # 再打印 grad_input\n",
        "    print('grad_input', grad_input)\n",
        "    # 保存到全局变量\n",
        "    total_grad_in.append(grad_input)\n",
        "    total_grad_out.append(grad_output)\n",
        "\n",
        "\n",
        "model = Model()\n",
        "\n",
        "modules = model.named_children()\n",
        "for name, module in modules:\n",
        "    module.register_backward_hook(hook_fn_backward)\n",
        "\n",
        "# 这里的 requires_grad 很重要，如果不加，backward hook 执行到第一层，对 x 的导数将为 None，\n",
        "# 某英文博客作者这里疏忽了\n",
        "# 此外再强调一遍 x 的维度，一定不能写成 torch.Tensor([1.0, 1.0, 1.0]).requires_grad_()\n",
        "# 否则 backward hook 会出问题。\n",
        "\n",
        "x = torch.Tensor([[1.0, 1.0, 1.0]]).requires_grad_()\n",
        "o = model(x)\n",
        "o.backward()\n",
        "\n",
        "print('==========Saved inputs and outputs==========')\n",
        "for idx in range(len(total_grad_in)):\n",
        "    print('grad output: ', total_grad_out[idx])\n",
        "    print('grad input: ', total_grad_in[idx])\n",
        "\n",
        "\n",
        "# output:\n",
        "'''\n",
        "Linear(in_features=4, out_features=1, bias=True)\n",
        "grad_output (tensor([[1.]]),)\n",
        "grad_input (tensor([1.]),     ------------------------------> bias导数\n",
        "      tensor([[1., 2., 3., 4.]]),    ----------------> input导数\n",
        "      tensor([[ 7.], [ 0.], [27.], [ 0.]]))  -------> weights导数\n",
        "\n",
        "ReLU()\n",
        "grad_output (tensor([[1., 2., 3., 4.]]),)\n",
        "grad_input (tensor([[1., 0., 3., 0.]]),)\n",
        "## ReLU 层反向传播时，只有输入大于 0 的位置，才会有梯度传回来，输入小于等于 0 的位置不再有梯度反传\n",
        "\n",
        "Linear(in_features=3, out_features=4, bias=True)\n",
        "grad_output (tensor([[1., 0., 3., 0.]]),)\n",
        "grad_input ( tensor([1., 0., 3., 0.]),       ------------------------------> bias导数\n",
        "       tensor([[22., 26., 30.]]),       ------------------------------> input导数\n",
        "       tensor([[1., 0., 3., 0.],  [1., 0., 3., 0.],  [1., 0., 3., 0.]])) -------> weights导数\n",
        "'''"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jwNBwv20WgtT",
        "outputId": "3f06173c-ea4a-46fd-ee53-5986307ee66a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Linear(in_features=4, out_features=1, bias=True)\n",
            "grad_output (tensor([[1.]]),)\n",
            "grad_input (tensor([1.]), tensor([[1., 2., 3., 4.]]), tensor([[ 7.],\n",
            "        [ 0.],\n",
            "        [27.],\n",
            "        [ 0.]]))\n",
            "ReLU()\n",
            "grad_output (tensor([[1., 2., 3., 4.]]),)\n",
            "grad_input (tensor([[1., 0., 3., 0.]]),)\n",
            "Linear(in_features=3, out_features=4, bias=True)\n",
            "grad_output (tensor([[1., 0., 3., 0.]]),)\n",
            "grad_input (tensor([1., 0., 3., 0.]), tensor([[22., 26., 30.]]), tensor([[1., 0., 3., 0.],\n",
            "        [1., 0., 3., 0.],\n",
            "        [1., 0., 3., 0.]]))\n",
            "==========Saved inputs and outputs==========\n",
            "grad output:  (tensor([[1.]]),)\n",
            "grad input:  (tensor([1.]), tensor([[1., 2., 3., 4.]]), tensor([[ 7.],\n",
            "        [ 0.],\n",
            "        [27.],\n",
            "        [ 0.]]))\n",
            "grad output:  (tensor([[1., 2., 3., 4.]]),)\n",
            "grad input:  (tensor([[1., 0., 3., 0.]]),)\n",
            "grad output:  (tensor([[1., 0., 3., 0.]]),)\n",
            "grad input:  (tensor([1., 0., 3., 0.]), tensor([[22., 26., 30.]]), tensor([[1., 0., 3., 0.],\n",
            "        [1., 0., 3., 0.],\n",
            "        [1., 0., 3., 0.]]))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1117: UserWarning: Using a non-full backward hook when the forward contains multiple autograd Nodes is deprecated and will be removed in future versions. This hook will be missing some grad_input. Please use register_full_backward_hook to get the documented behavior.\n",
            "  warnings.warn(\"Using a non-full backward hook when the forward contains multiple autograd Nodes \"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![ebd1c6f101e680ae00484e2dcf45577.jpg](data:image/jpeg;base64,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)"
      ],
      "metadata": {
        "id": "SWsq5LAjtU9X"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yW67bAogQnd2"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}