step8to9_对自动反向传播代码进行优化.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 对自动反向传播代码进行优化\n",
    "> 1. 定义函数祖类Function时使用循环而非递归的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#更改变量类Variable的功能\n",
    "\n",
    "import numpy as np\n",
    "class Variable:\n",
    "    def __init__(self,data):\n",
    "        self.data = data        \n",
    "        self.grad = None\n",
    "        #新拓展\n",
    "        self.creator = None         #记录变量的创造函数\n",
    "\n",
    "        #新拓展\n",
    "    def set_creator(self,func):\n",
    "        self.creator = func\n",
    "\n",
    "        #新拓展\n",
    "    def backward(self):\n",
    "        funcs = [self.creator]\n",
    "        while funcs:\n",
    "            f = funcs.pop()\n",
    "            x,y = f.input,f.output\n",
    "            x.grad = f.backward(y.grad)\n",
    "            if x.creator is not None:\n",
    "                funcs.append(x.creator)\n",
    "\n",
    "\n",
    "class Function:\n",
    "    def __call__(self,input):\n",
    "        x = input.data\n",
    "        y = self.forward(x)\n",
    "        output = Variable(y)\n",
    "        output.set_creator(self)    #设置产生变量的creator属性，不可省略，与Variable类反向传播的第17行有强耦合性\n",
    "        self.input = input\n",
    "        #新拓展\n",
    "        self.output = output       #思考可以省略吗?\n",
    "        return output\n",
    "    \n",
    "    def forward(self,input):\n",
    "        raise NotImplementedError()\n",
    "    \n",
    "    def backward(self,gy):\n",
    "        raise NotImplementedError()\n",
    "\n",
    "class Square(Function):\n",
    "    def forward(self,x):\n",
    "        y = x**2\n",
    "        return y\n",
    "\n",
    "    def backward(self, gy):\n",
    "        x = self.input.data\n",
    "        gx = x*2*gy\n",
    "        return gx\n",
    "\n",
    "class Exp(Function):\n",
    "    def forward(self, x):\n",
    "        y = np.exp(x)\n",
    "        return y\n",
    "    \n",
    "    def backward(self,gy):\n",
    "        x = self.input.data\n",
    "        gx = np.exp(x)*gy\n",
    "        return gx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.297442541400256\n"
     ]
    }
   ],
   "source": [
    "#使用\n",
    "A = Square()\n",
    "B = Exp()\n",
    "C = Square()\n",
    "\n",
    "x = Variable(np.array(0.5))\n",
    "#a = A(x)\n",
    "a = Square()(x)\n",
    "b = B(a)\n",
    "y = C(b)\n",
    "\n",
    "y.grad = np.array(1.0)\n",
    "y.backward()\n",
    "print(x.grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 2. 使用工厂函数去简化函数类实例的生成过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 工厂函数\n",
    "def square(x):\n",
    "    return Square()(x)\n",
    "\n",
    "def exp(x):\n",
    "    return Exp()(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.297442541400256\n"
     ]
    }
   ],
   "source": [
    "#使用\n",
    "x = Variable(np.array(0.5))\n",
    "y = square(exp(square(x)))\n",
    "\n",
    "y.grad = np.array(1.0)\n",
    "y.backward()\n",
    "print(x.grad)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 3. 简化反向传播的首个步骤，定义y关于其自身的导数：即省略 y.grad = no.array(1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#在变量Variable类的反向传播方法开头增加对其grad属性的判断\n",
    "\n",
    "class Variable:\n",
    "    def __init__(self,data):\n",
    "        self.data = data        \n",
    "        self.grad = None\n",
    "        #新拓展\n",
    "        self.creator = None         #记录变量的创造函数\n",
    "\n",
    "        #新拓展\n",
    "    def set_creator(self,func):\n",
    "        self.creator = func\n",
    "\n",
    "        #新拓展\n",
    "    def backward(self):\n",
    "        if self.grad is None:\n",
    "            self.grad = np.ones_like(self.data)\n",
    "        funcs = [self.creator]\n",
    "        while funcs:\n",
    "            f = funcs.pop()\n",
    "            x,y = f.input,f.output\n",
    "            x.grad = f.backward(y.grad)\n",
    "            if x.creator is not None:\n",
    "                funcs.append(x.creator)\n",
    "\n",
    "'''下不变'''                \n",
    "class Function:\n",
    "    def __call__(self,input):\n",
    "        x = input.data\n",
    "        y = self.forward(x)\n",
    "        output = Variable(y)\n",
    "        output.set_creator(self)    #设置产生变量的creator属性，不可省略，与Variable类反向传播的第17行有强耦合性\n",
    "        self.input = input\n",
    "        #新拓展\n",
    "        self.output = output       #思考可以省略吗?\n",
    "        return output\n",
    "    \n",
    "    def forward(self,input):\n",
    "        raise NotImplementedError()\n",
    "    \n",
    "    def backward(self,gy):\n",
    "        raise NotImplementedError()\n",
    "\n",
    "class Square(Function):\n",
    "    def forward(self,x):\n",
    "        y = x**2\n",
    "        return y\n",
    "\n",
    "    def backward(self, gy):\n",
    "        x = self.input.data\n",
    "        gx = x*2*gy\n",
    "        return gx\n",
    "\n",
    "class Exp(Function):\n",
    "    def forward(self, x):\n",
    "        y = np.exp(x)\n",
    "        return y\n",
    "    \n",
    "    def backward(self,gy):\n",
    "        x = self.input.data\n",
    "        gx = np.exp(x)*gy\n",
    "        return gx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 4. 只支持ndarray类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "# 在Variable类的初始化函数开始先进行类型判断\n",
    "class Variable:\n",
    "    def __init__(self,data):\n",
    "        if data is not None:\n",
    "            if not isinstance(data,np.ndarray):\n",
    "                raise TypeError('{} is not supported'.format(type(data)))\n",
    "        self.data = data\n",
    "        self.grad = None\n",
    "        self.creator = None\n",
    "```\n",
    "```python\n",
    "# 定义一个函数，将标量转换为ndarray类型\n",
    "'''\n",
    "np.isscalar(x) 检查输入 x 是否为标量值（如 int, float 等）\n",
    "如果是标量，则使用 np.array(x) 将其转换为 NumPy 数组\n",
    "如果不是标量（即已经是数组），则直接返回原值\n",
    "这个函数在深度学习框架中很重要，因为它确保了所有数据都以 NumPy 数组的形式进行处理\n",
    "'''\n",
    "def as_array(x):\n",
    "    if np.isscalar(x):\n",
    "        return np.array(x)\n",
    "    return x\n",
    "\n",
    "class Function:\n",
    "    def __call__(self,input):\n",
    "        x = input.data\n",
    "        y = self.forward(x)\n",
    "        output = Variable(as_array(y))\n",
    "        output.set_creator(self )\n",
    "        self.input = input\n",
    "        self.output = output\n",
    "        return output\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q：np.array(3.0)为什么不是nd.array类型，使得print(np.isscalar(np.array(3.0)))输出false？\n",
    "\n",
    "A：np.array(3.0) 生成的是一个零维数组（0-dimensional array），而不是标量（scalar）。在 NumPy 中，标量是单个数值，而零维数组是包含一个元素的数组。\n",
    "因此，当你使用 np.isscalar(np.array(3.0)) 时，它会返回 False，因为 np.array(3.0) 是一个数组对象，而不是标量。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}