BasicAutomaticDifferentiation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基本自动微分方法（Automatic Differentiation AD）\n",
    "\n",
    "自动微分有两种形式，其分别为前向模式（Forward Mode）和反向模式（Reverse Mode）\n",
    "\n",
    "* Forward Mode依靠**二元数**，在前向运算过程中同时计算值和导数值\n",
    "* Reverse Mode分为两个步骤，第一步为前向运算，第二步为反向传播\n",
    "\n",
    "参考论文：[Automatic Differentiation in Machine Learning: a Survey](https://arxiv.org/pdf/1502.05767.pdf)\n",
    "\n",
    "参考实现：[autograd-by-borgwang](https://github.com/borgwang/toys/blob/master/ml-autograd/autograd.ipynb)\n",
    "\n",
    "参考解析：\n",
    "\n",
    "1. [神经网络自动求导的设计与实现](https://zhuanlan.zhihu.com/p/82582926)\n",
    "\n",
    "2. [tensorflow的函数自动求导是如何实现的](https://www.zhihu.com/question/54554389)\n",
    "\n",
    "在这里，由于是对神经网络的分析，因此主要讨论自动微分的**Reverse Mode**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AD实现要点\n",
    "\n",
    "对于AD，其在运算过程中需要记录如下数据\n",
    "\n",
    "* 当前运算的运算结果\n",
    "* 当前运算的梯度计算方法\n",
    "* 当前运算直接依赖的前置运算\n",
    "\n",
    "## AD过程：\n",
    "\n",
    "假设已完成前向计算，并保留了上述需要的数据\n",
    "\n",
    "* 从整个运算的结果出发，记录当前运算的梯度，并将梯度传递给当前运算直接依赖的前置运算\n",
    "* 递归上述步骤，直到所有计算结束\n",
    "\n",
    "## 基于AD的神经网络优化流程\n",
    "* **运算定义**：若要实现AD，每一个运算不仅要计算结果，还需要对运算的前置依赖关系以及梯度计算方法进行记录\n",
    "* **反向传播**: 在完成正向计算后，需要进行反向传播\n",
    "* **参数更新**：在完成反向传播后，依靠梯度计算结果更新参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import imageio\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "random.seed(1024)\n",
    "np.random.seed(1024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def as_tensor(obj):\n",
    "    if not isinstance(obj, MyTensor):\n",
    "        obj = MyTensor(obj)\n",
    "    return obj\n",
    "\n",
    "def build_binary_ops_result_tensor(tensor1, tensor2, grad_func_tensor1, grad_func_tensor2, values):\n",
    "    \"\"\"\n",
    "    建立二元运算结果的tensor\n",
    "    \"\"\"\n",
    "    requires_grad = tensor1.requires_grad or tensor2.requires_grad\n",
    "    \n",
    "    dependency = list()\n",
    "    if tensor1.requires_grad:\n",
    "        dependency.append({\"tensor\": tensor1, \"grad_func\": grad_func_tensor1})\n",
    "    if tensor2.requires_grad:\n",
    "        dependency.append({\"tensor\": tensor2, \"grad_func\": grad_func_tensor2})\n",
    "\n",
    "    return MyTensor(values, requires_grad, dependency)\n",
    "\n",
    "def build_unary_ops_result_tensor(tensor, grad_func, values):\n",
    "    \"\"\"\n",
    "    建立一元运算结果的tensor\n",
    "    \"\"\"\n",
    "\n",
    "    requires_grad = tensor.requires_grad\n",
    "    dependency = list()\n",
    "\n",
    "    if tensor.requires_grad:\n",
    "        dependency.append({\"tensor\": tensor, \"grad_func\": grad_func})\n",
    "    \n",
    "    return MyTensor(values, requires_grad, dependency) \n",
    "\n",
    "\n",
    "class MyTensor(object):\n",
    "\n",
    "    def __init__(self, values, requires_grad=False, dependency=None):\n",
    "        self._values = np.array(values)\n",
    "        self._shape = self._values.shape\n",
    "\n",
    "        self.grad = None\n",
    "        self.requires_grad = requires_grad\n",
    "\n",
    "        if self.requires_grad:\n",
    "            self.zero_grad()\n",
    "\n",
    "        if dependency is None:\n",
    "            self.dependency = list()\n",
    "        else:\n",
    "            self.dependency = dependency\n",
    "        \n",
    "    def zero_grad(self):\n",
    "        self.grad = np.zeros(self._shape)\n",
    "    \n",
    "    @property\n",
    "    def values(self):\n",
    "        return self._values\n",
    "    \n",
    "    @ property\n",
    "    def shape(self):\n",
    "        return self._shape\n",
    "    \n",
    "    @values.setter\n",
    "    def values(self, values):\n",
    "        self._values = np.array(values)\n",
    "        self.grad = None\n",
    "\n",
    "    def backward(self, grad=None):\n",
    "        \"\"\"\n",
    "        反向传播核心代码，累计当前tensor的梯度，同时反向传播梯度\n",
    "        \"\"\"\n",
    "        assert self.requires_grad, \"Call backward() on a non-requires-grad tensor\"\n",
    "\n",
    "        if grad is None:\n",
    "            grad = 1.0\n",
    "        grad = np.array(grad)\n",
    "\n",
    "        # 梯度叠加\n",
    "        self.grad += grad\n",
    "\n",
    "        # 反向传播梯度到直接依赖的运算\n",
    "        for dep in self.dependency:\n",
    "            # 注意这里是直接将梯度传播到依赖的运算，而不是传播梯度叠加的结果\n",
    "            # 其原因在于这里使用的是深度优先遍历\n",
    "            # 由于在反向传播梯度后，会进行直接依赖的运算反向传播，因此是深度优先\n",
    "            # 这么一来在遍历完成后，所有经过当前运算传递到依赖运算的路径均会被搜索到\n",
    "            \n",
    "            # 比如\n",
    "            # 假设当前节点前有两个后继节点\n",
    "            # 那么反向传播流程为\n",
    "\n",
    "            # 梯度清零\n",
    "            # 后继节点一反向传播，当前节点梯度+grad_1\n",
    "            # 当前节点继续反向传播，前置节点梯度+grad_1\n",
    "            # 另一条路径：后继节点二反向传播，当前节点梯度+grad_2\n",
    "            # 当前节点继续反向传播，前置节点梯度+grad_2\n",
    "\n",
    "            # 若在上述过程中每次传递的是累计梯度，则会导致前置节点梯度+grad_1+(grad_1+grad_2)\n",
    "            # 即在第二条路径中对第一条路径的梯度又叠加了一次\n",
    "            grad_cal_method_for_dep = dep[\"grad_func\"](grad)\n",
    "            # 迭代调用直接依赖的运算的反向传播\n",
    "            dep[\"tensor\"].backward(grad_cal_method_for_dep)\n",
    "    \n",
    "    # 运算重载，对于反向传播，其不仅要计算值，还需要计算梯度\n",
    "    # 重载运算\n",
    "\n",
    "    # 二元运算：\n",
    "    # 矩阵乘法：左乘、右乘、原位乘\n",
    "    # 加法：左加、右加、原位加\n",
    "    # 减法：左减、右减、原位减\n",
    "    # 按位乘法：左乘、右乘、原位乘\n",
    "\n",
    "    # 一元运算：\n",
    "    # 取反\n",
    "\n",
    "    def __add__(self, other):\n",
    "        \"\"\"\n",
    "        右加法重载\n",
    "        \n",
    "        return: self + other\n",
    "        \"\"\"\n",
    "        return self._add(self, as_tensor(other))\n",
    "    \n",
    "    def __radd__(self, other):\n",
    "        \"\"\"\n",
    "        左加法重载\n",
    "\n",
    "        return: other + self\n",
    "        \"\"\"\n",
    "        return self._add(as_tensor(other), self)\n",
    "    \n",
    "    def __iadd__(self, other):\n",
    "        \"\"\"\n",
    "        原位加法重载\n",
    "\n",
    "        self += other\n",
    "\n",
    "        原位加法不会生成新的节点，因此不会记录梯度\n",
    "        \"\"\"\n",
    "        self.values = self.values + as_tensor(other).values\n",
    "        return self\n",
    "\n",
    "    def _add(self, tensor1, tensor2):\n",
    "        \"\"\"\n",
    "        运算为：c = a + b\n",
    "\n",
    "        Dc/Da = 1\n",
    "        Dc/Db = 1\n",
    "\n",
    "        在本运算中，要求 a.shape == b.shape == c.shape\n",
    "        或者使用numpy默认的broadcast机制\n",
    "\n",
    "        对于维度匹配的加法，梯度直接传递即可\n",
    "        对于维度无法匹配需要采用broadcast机制进行计算的加法，需要对维度进行处理\n",
    "\n",
    "        broadcast机制：\n",
    "        这里仅考虑二维的情况\n",
    "\n",
    "        1. 对于形如 (m, n) + (n, ) -> (m, n)形式的broadcast:\n",
    "        对于第一个加数，将计算结果的梯度直接赋予当前加数即可\n",
    "        对于第二个加数，其需要将计算结果的梯度沿第一维度叠加，然后赋予当前加数\n",
    "\n",
    "        2. 对于形如(m, n) + (1, n) -> (m, n)形式的broadcast：\n",
    "        对于第一个加数，将计算结果的梯度直接赋予当前加数即可\n",
    "        对于第二个加数，其需要将计算结果的梯度沿第一维度叠加，并保留维度，然后赋予当前加数\n",
    "        \"\"\"\n",
    "        _result = tensor1.values + tensor2.values\n",
    "\n",
    "        def grad_func_tensor1(grad):\n",
    "\n",
    "            # 处理第一种情况\n",
    "            # 此时，若当前tensor的维度要小于grad的维度，则说明存在第一种broadcast\n",
    "            for _ in range(grad.ndim - tensor1.values.ndim):\n",
    "                grad = grad.sum(axis=0)\n",
    "            # 处理第二种情况\n",
    "            # 此时，若当前tensor的维度等于grad的维度，但是存在为1的维度，则说明可能是第二种broadcast\n",
    "            for i, dim in enumerate(tensor1.values.shape):\n",
    "                if dim == 1:\n",
    "                    grad = grad.sum(axis=i, keepdims=True)\n",
    "            return grad\n",
    "\n",
    "        def grad_func_tensor2(grad):\n",
    "            # 同上\n",
    "            for _ in range(grad.ndim - tensor2.values.ndim):\n",
    "                grad = grad.sum(axis=0)\n",
    "            for i, dim in enumerate(tensor2.values.shape):\n",
    "                if dim == 1:\n",
    "                    grad = grad.sum(axis=i, keepdims=True)\n",
    "            return grad\n",
    "        \n",
    "        return build_binary_ops_result_tensor(tensor1, tensor2, grad_func_tensor1, grad_func_tensor2, _result)\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        \"\"\"\n",
    "        右减法重载\n",
    "        \n",
    "        return: self - other\n",
    "        \"\"\"\n",
    "        return self._sub(self, as_tensor(other))\n",
    "    \n",
    "    def __rsub__(self, other):\n",
    "        \"\"\"\n",
    "        左减法重载\n",
    "\n",
    "        return：other - self\n",
    "        \"\"\"\n",
    "        return self._sub(as_tensor(other), self)\n",
    "    \n",
    "    def __isub__(self, other):\n",
    "        \"\"\"\n",
    "        原位减法\n",
    "        self -= other\n",
    "\n",
    "        原位减法不会生成新的节点，因此不会记录梯度\n",
    "        \"\"\"\n",
    "        self.values = self.values - as_tensor(other).values\n",
    "        return self\n",
    "\n",
    "    def _sub(self, tensor1, tensor2):\n",
    "        \"\"\"\n",
    "        运算为：c = a - b\n",
    "\n",
    "        Dc/Da = 1\n",
    "        Dc/Db = -1\n",
    "        在本运算中，要求 a.shape == b.shape == c.shape\n",
    "        或者使用numpy默认的broadcast机制\n",
    "\n",
    "        分析同_add\n",
    "        \"\"\"\n",
    "        _result = tensor1.values - tensor2.values\n",
    "\n",
    "        def grad_func_tensor1(grad):\n",
    "\n",
    "            # 处理第一种情况\n",
    "            # 此时，若当前tensor的维度要小于grad的维度，则说明存在第一种broadcast\n",
    "            for _ in range(grad.ndim - tensor1.values.ndim):\n",
    "                grad = grad.sum(axis=0)\n",
    "            # 处理第二种情况\n",
    "            # 此时，若当前tensor的维度等于grad的维度，但是存在为1的维度，则说明可能是第二种broadcast\n",
    "            for i, dim in enumerate(tensor1.values.shape):\n",
    "                if dim == 1:\n",
    "                    grad = grad.sum(axis=i, keepdims=True)\n",
    "            return grad\n",
    "\n",
    "        def grad_func_tensor2(grad):\n",
    "            # 同上\n",
    "            for _ in range(grad.ndim - tensor2.values.ndim):\n",
    "                grad = grad.sum(axis=0)\n",
    "            for i, dim in enumerate(tensor2.values.shape):\n",
    "                if dim == 1:\n",
    "                    grad = grad.sum(axis=i, keepdims=True)\n",
    "            return -grad\n",
    "        \n",
    "        return build_binary_ops_result_tensor(tensor1, tensor2, grad_func_tensor1, grad_func_tensor2, _result)\n",
    "    \n",
    "    def __matmul__(self, other):\n",
    "        \"\"\"\n",
    "        矩阵右乘\n",
    "\n",
    "        return self @ other\n",
    "        \"\"\"\n",
    "        return self._matmul(self, as_tensor(other))\n",
    "    \n",
    "    def __rmatmul__(self, other):\n",
    "        \"\"\"\n",
    "        矩阵左乘\n",
    "        \n",
    "        return other @ self\n",
    "        \"\"\"\n",
    "        return self._matmul(as_tensor(other), self)\n",
    "    \n",
    "    def __imatmul__(self, other):\n",
    "        \"\"\"\n",
    "        原位乘法\n",
    "        self @= other\n",
    "        \"\"\"\n",
    "        self.values = self.values @ as_tensor(other).values\n",
    "        return self\n",
    "\n",
    "    def _matmul(self, tensor1, tensor2):\n",
    "        \"\"\"\n",
    "        运算为: c = a @ b\n",
    "\n",
    "        Dc/Da = grad @ b.T\n",
    "        Dc/Db = a.T @ grad\n",
    "        \"\"\"\n",
    "        if tensor1.shape[1] != tensor2.shape[0]:\n",
    "            raise RuntimeError(\"RuntimeError: size mismatch, m1: {}, m2: {}\".format(tensor1.shape, tensor2.shape))\n",
    "\n",
    "        _result = tensor1.values @ tensor2.values\n",
    "        def grad_func_tensor1(grad):\n",
    "            return grad @ tensor2.values.T\n",
    "        \n",
    "        def grad_func_tensor2(grad):\n",
    "            return tensor1.values.T @ grad\n",
    "\n",
    "        return build_binary_ops_result_tensor(tensor1, tensor2, grad_func_tensor1, grad_func_tensor2, _result)\n",
    "\n",
    "    def __neg__(self):\n",
    "        \"\"\"\n",
    "        取反运算\n",
    "        return -self\n",
    "        \"\"\"\n",
    "        return self._neg(self)\n",
    "    \n",
    "    def _neg(self, tensor):\n",
    "        \"\"\"\n",
    "        运算为: c = -a\n",
    "\n",
    "        Dc/Da = -1\n",
    "        \"\"\"\n",
    "        _result = -tensor.values\n",
    "\n",
    "        def grad_func(grad):\n",
    "            return -grad\n",
    "        \n",
    "        return build_unary_ops_result_tensor(tensor, grad_func, _result)\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        \"\"\"\n",
    "        按位右乘\n",
    "\n",
    "        reture self * other\n",
    "        \"\"\"\n",
    "        return self._mul(self, as_tensor(other))\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        \"\"\"\n",
    "        按位左乘\n",
    "\n",
    "        return other * self\n",
    "        \"\"\"\n",
    "        return self._mul(as_tensor(other), self)\n",
    "    \n",
    "    def __imul__(self, other):\n",
    "        \"\"\"\n",
    "        原位按位乘\n",
    "\n",
    "        self *= other\n",
    "        \"\"\"\n",
    "        self.values = self.values * as_tensor(other).values\n",
    "        return self\n",
    "\n",
    "    def _mul(self, tensor1, tensor2):\n",
    "        \"\"\"\n",
    "        运算为: c = a * b\n",
    "\n",
    "        Dc/Da = b\n",
    "        Dc/Db = a\n",
    "\n",
    "        在本运算中，要求 a.shape == b.shape == c.shape\n",
    "        或者使用numpy默认的broadcast机制\n",
    "\n",
    "        对于维度匹配的加法，梯度直接传递即可\n",
    "        对于维度无法匹配需要采用broadcast机制进行计算的加法，需要对维度进行处理\n",
    "\n",
    "        由于\n",
    "        Dc/Da = b\n",
    "        Dc/Db = a\n",
    "        因此在计算梯度时，不同于add，按位乘法需要依赖numpy的broadcast首先计算梯度值，然后处理维度问题\n",
    "        即：\n",
    "        tensor1.grad = grad * tensor2.grad\n",
    "        tensor2.grad = grad * tensor1.grad\n",
    "\n",
    "        维度处理同add\n",
    "        \"\"\"\n",
    "        _result = tensor1.values * tensor2.values\n",
    "\n",
    "        def grad_func_tensor1(grad):\n",
    "            grad = grad * tensor2.values\n",
    "\n",
    "            # 处理第一种情况\n",
    "            # 此时，若当前tensor的维度要小于grad的维度，则说明存在第一种broadcast\n",
    "            for _ in range(grad.ndim - tensor1.values.ndim):\n",
    "                grad = grad.sum(axis=0)\n",
    "            # 处理第二种情况\n",
    "            # 此时，若当前tensor的维度等于grad的维度，但是存在为1的维度，则说明可能是第二种broadcast\n",
    "            for i, dim in enumerate(tensor1.values.shape):\n",
    "                if dim == 1:\n",
    "                    grad = grad.sum(axis=i, keepdims=True)\n",
    "            return grad\n",
    "\n",
    "        def grad_func_tensor2(grad):\n",
    "            grad = grad * tensor1.values\n",
    "            # 同上\n",
    "            for _ in range(grad.ndim - tensor2.values.ndim):\n",
    "                grad = grad.sum(axis=0)\n",
    "            for i, dim in enumerate(tensor2.values.shape):\n",
    "                if dim == 1:\n",
    "                    grad = grad.sum(axis=i, keepdims=True)\n",
    "            return grad\n",
    "        \n",
    "        return build_binary_ops_result_tensor(tensor1, tensor2, grad_func_tensor1, grad_func_tensor2, _result)\n",
    "\n",
    "    def sum(self, axis=None):\n",
    "        return _sum(self, axis=axis)\n",
    "\n",
    "    def mean(self, axis=None):\n",
    "        return _mean(self, axis)\n",
    "\n",
    "\n",
    "# sum\n",
    "def _sum(tensor, axis=None):\n",
    "    \"\"\"\n",
    "    运算：c = np.sum(a, axis)\n",
    "\n",
    "    Dc/Da = 1\n",
    "\n",
    "    若是求全部维度的和，即axis=None，则输出为grad * np.ones_list(a.shape)\n",
    "    若是按照特定维度进行求和，则需要首先将grad扩展为和a相同的shape，然后输出\n",
    "    \"\"\"\n",
    "    _result = tensor.values.sum(axis=axis)\n",
    "\n",
    "    # 获取求和维度对应的shape\n",
    "    if axis is not None:\n",
    "        dim_repeat = tensor.values.shape[axis]\n",
    "\n",
    "    def grad_func(grad):\n",
    "        if axis is None:\n",
    "            grad = grad * np.ones_like(tensor.values)\n",
    "        else:\n",
    "            # 维度扩展\n",
    "            grad = np.expand_dims(grad, axis)\n",
    "            # 重新生成shape\n",
    "            grad = np.repeat(grad, dim_repeat, axis)\n",
    "    \n",
    "    return build_unary_ops_result_tensor(tensor, grad_func, _result)\n",
    "\n",
    "# mean\n",
    "def _mean(tensor, axis=None):\n",
    "    \"\"\"\n",
    "    运算：c = np.mean(a, axis)\n",
    "\n",
    "    Dc/Da = 1/len(a.shape[axis])\n",
    "\n",
    "    若是求全部维度的均值，即axis=None，则输出为grad * np.ones_list(a.shape) / np.prod(a.shape)\n",
    "    若是按照特定维度进行求和，则需要首先将grad扩展为和a相同的shape，然后输出\n",
    "    \"\"\"\n",
    "    _result = tensor.values.mean(axis=axis)\n",
    "\n",
    "    # 获取求和维度对应的shape\n",
    "    if axis is not None:\n",
    "        dim_repeat = tensor.values.shape[axis]\n",
    "\n",
    "    def grad_func(grad):\n",
    "        if axis is None:\n",
    "            grad = grad * np.ones_like(tensor.values) / np.prod(tensor.values.shape)\n",
    "        else:\n",
    "            # 维度扩展\n",
    "            grad = np.expand_dims(grad, axis)\n",
    "            # 重新生成shape并除以相应的维度\n",
    "            grad = np.repeat(grad, dim_repeat, axis) / np.prod(dim_repeat)\n",
    "    \n",
    "    return build_unary_ops_result_tensor(tensor, grad_func, _result)\n",
    "\n",
    "# sigmoid\n",
    "def sigmoid(tensor, inplace=False):\n",
    "    \"\"\"\n",
    "    运算为 c = 1/(1+e^(-a))\n",
    "\n",
    "    Dc/Da = c(1-c)\n",
    "    \"\"\"\n",
    "    _result = 1/(1+np.power(np.e, -tensor.values))\n",
    "\n",
    "    def grad_func(grad):\n",
    "            return grad * _result * (1 - _result)\n",
    "\n",
    "    return build_unary_ops_result_tensor(tensor, grad_func, _result)\n",
    "\n",
    "# ReLU\n",
    "def ReLU(tensor, inplace=False):\n",
    "    \"\"\"\n",
    "    运算为 c = 0 if a<= 0 or c = a\n",
    "\n",
    "    Dc/Da = 0 if a <= 0 or Dc/Da = 1\n",
    "\n",
    "    # ATTENTION!!!!!\n",
    "    # Inplace模式有严重 BUG，有待修复\n",
    "    # TODO: Inplace Mode\n",
    "    \"\"\"\n",
    "    # 建立mask\n",
    "    _mask = np.array(tensor.values > 0).astype(np.int32)\n",
    "\n",
    "    if inplace:\n",
    "        # 直接原位操作\n",
    "        tensor.values *= _mask\n",
    "        # # 梯度处理\n",
    "        def grad_func(grad):\n",
    "            grad = grad * _mask\n",
    "            return grad\n",
    "        if tensor.requires_grad:\n",
    "            tensor.dependency.append({\"tensor\": tensor, \"grad_func\": grad_func})\n",
    "        return tensor\n",
    "    else:\n",
    "        _result = tensor.values * _mask\n",
    "\n",
    "        def grad_func(grad):\n",
    "            grad = grad * _mask\n",
    "            return grad\n",
    "        \n",
    "        return build_unary_ops_result_tensor(tensor, grad_func, _result)\n",
    "\n",
    "def Tanh(tensor, inplace=False):\n",
    "    \"\"\"\n",
    "    运算为 c = (1-e^(-2x))/(1+e^(-2x))\n",
    "\n",
    "    Dc/Da = 1 - c^2\n",
    "    \"\"\"\n",
    "    exp_tensor = np.exp(-2 * tensor.values)\n",
    "    _result = (1-exp_tensor)/(1+exp_tensor)\n",
    "\n",
    "    def grad_func(grad):\n",
    "        grad = grad * (1 - np.power(_result, 2))\n",
    "        return grad\n",
    "    \n",
    "    return build_unary_ops_result_tensor(tensor, grad_func, _result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch-40 \tloss: 0.6697\n",
      "epoch-80 \tloss: 0.5037\n",
      "epoch-120 \tloss: 0.4202\n",
      "epoch-160 \tloss: 0.3749\n",
      "epoch-200 \tloss: 0.3479\n",
      "epoch-240 \tloss: 0.3298\n",
      "epoch-280 \tloss: 0.3161\n",
      "epoch-320 \tloss: 0.3049\n",
      "epoch-360 \tloss: 0.2949\n",
      "epoch-400 \tloss: 0.2858\n",
      "epoch-440 \tloss: 0.2773\n",
      "epoch-480 \tloss: 0.2693\n",
      "epoch-520 \tloss: 0.2616\n",
      "epoch-560 \tloss: 0.2544\n",
      "epoch-600 \tloss: 0.2474\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x750 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### test\n",
    "\n",
    "# training data\n",
    "np.random.seed(1024)\n",
    "random.seed(1024)\n",
    "Epochs = 600\n",
    "x = MyTensor(np.sort(np.random.normal(-1, 1.0, (100, 1)), axis=0))\n",
    "y = MyTensor(np.exp(x.values) - 3) \n",
    "\n",
    "plt.figure(figsize=(10, 5), dpi=150)\n",
    "\n",
    "params = {\n",
    "    \"w_1\": MyTensor(np.random.normal(0, 1.0, (1, 5)), requires_grad=True),\n",
    "    \"b_1\": MyTensor(np.random.normal(0, 1.0, 5), requires_grad=True),\n",
    "    \"w_2\": MyTensor(np.random.normal(0, 1.0, (5, 1)), requires_grad=True),\n",
    "    \"b_2\": MyTensor(np.random.normal(0, 1.0, 1), requires_grad=True)\n",
    "}\n",
    "\n",
    "learng_rate = 2e-4\n",
    "loss_list = []\n",
    "for e in range(1, Epochs+1):\n",
    "    # set gradient to zero\n",
    "    for param in params.values():\n",
    "        param.zero_grad()\n",
    "    \n",
    "    # forward\n",
    "    hidden_1 = sigmoid(x @ params[\"w_1\"] + params[\"b_1\"], inplace=False)\n",
    "    predicted = hidden_1 @ params[\"w_2\"] + params[\"b_2\"]\n",
    "    err = predicted - y\n",
    "    loss = (err * err).mean()\n",
    "    \n",
    "    # backward automatically\n",
    "    loss.backward()\n",
    "    \n",
    "    # updata parameters\n",
    "    for param in params.values():\n",
    "        param -= learng_rate * param.grad\n",
    "        \n",
    "    loss_list.append(loss.values)\n",
    "    if e % 40 == 0:\n",
    "        print(\"epoch-%i \\tloss: %.4f\" % (e, loss.values))\n",
    "\n",
    "    # 记录图片\n",
    "    if e % 10 == 0:\n",
    "        plt.cla()\n",
    "        plt.clf()\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.ylim(-4, 3)\n",
    "        plt.scatter(x.values, y.values, c=\"b\", label=\"data\")\n",
    "        plt.plot(x.values, predicted.values, c=\"r\", label=\"regression\")\n",
    "        plt.legend()\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.plot(loss_list)\n",
    "        plt.grid()\n",
    "        plt.xlabel(\"Epochs\")\n",
    "        plt.ylabel(\"loss\")\n",
    "        plt.savefig(\"./images/temp/{}.png\".format(e), dpi=150)\n",
    "\n",
    "with imageio.get_writer(\"./images/{}.gif\".format(\"AD_test_data\"), mode=\"I\", fps=2) as Writer:\n",
    "    for ind in range(1, Epochs+1):\n",
    "        if ind % 10 == 0:\n",
    "            image = imageio.imread(\"./images/temp/{}.png\".format(ind))\n",
    "            os.remove(\"./images/temp/{}.png\".format(ind))\n",
    "            Writer.append_data(image)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/AD_test_data.gif)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a2ae398f54937c2e9a792e0245dde3e7f00c22003a4409849c6155f07537f255"
  },
  "kernelspec": {
   "display_name": "Python 3.8.0 64-bit ('DIP': conda)",
   "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.8.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}