深度学习（斋藤康毅）学习条记（六）反向传播3

上一篇文章先容了反向传播的自动化，但也存在一些题目，本章用于分析这些题目，并修改原有框架，使其支持复杂盘算图的运行：
题目一：重复利用一个变量，梯度不会累计

也就是说，反向传播时gx=[1,1]，f.inputs=[x,x],在循环中第二次赋值把第一次赋的值给覆盖了。

怎样办理

题目二：重复盘算导数，梯度不会自动清零

第一次盘算，x的导数是2，第二次盘算x的导数是3。但是两次的导数值累加了。

设置x.cleargrad() 手动清空梯度

题目三：不支持复杂盘算图

循环	funs中的函数
0（初始化）	[D]
1	[B，C]
2	[B，A]
3	[B]
4	[A]
5	[ ]

怎样办理

代码验证

完备代码

1. import numpy as np
3. class Variable:
4.     def __init__(self, data):
5.         if data is not None:
6.             if not isinstance(data, np.ndarray):
7.                 raise TypeError('{} is not supported'.format(type(data)))
8.         self.data = data
9.         self.grad = None
10.         self.creator = None
11.         self.generation = 0
13.     def set_creator(self, func):
14.         self.creator = func
15.         self.generation = func.generation + 1
17.     def cleargrad(self):
18.         self.grad = None
20.     def backward(self):
21.         if self.grad is None:
22.             self.grad = np.ones_like(self.data)
23.         funcs = []
24.         seen_set = set()
26.         def addfunc(f):
27.             if f not in seen_set:
28.                 funcs.append(f)
29.                 seen_set.add(f)
30.                 funcs.sort(key=lambda x: x.generation)#funcs按照从小到大的辈分排序
32.         addfunc(self.creator)
34.         while funcs:
35.             f = funcs.pop()
36.             gys = [output.grad for output in f.outputs]  # 获取所有输出的梯度
37.             gxs = f.backward(*gys)                       # 调用 backward 方法
38.             if not isinstance(gxs, tuple):               # 确保 gxs 是元组
39.                 gxs = (gxs,)
40.             for x, gx in zip(f.inputs, gxs):            # 为每个输入分配梯度
41.                 if x.grad is None:
42.                     x.grad = gx
43.                 else:
44.                     x.grad = x.grad + gx
45.                 if x.creator is not None:
46.                     addfunc(x.creator)
48. class Function:
49.     def __call__(self, *inputs):
50.         xs = [x.data for x in inputs]               # 提取输入数据
51.         ys = self.forward(*xs)                      # 前向传播（解包）
52.         if not isinstance(ys, tuple):               # 确保 ys 是元组
53.             ys = (ys,)
54.         outputs = [Variable(as_array(y)) for y in ys]  # 创建输出变量
56.         self.generation = max([x.generation for x in inputs])
57.         for output in outputs:
58.             output.set_creator(self)
59.         self.inputs = inputs                        # 保存输入
60.         self.outputs = outputs                      # 保存输出
61.         return outputs if len(outputs) > 1 else outputs[0]  # 根据输出数量返回
63.     def forward(self, *xs):
64.         raise NotImplementedError()
66.     def backward(self, *gys):
67.         raise NotImplementedError()
69. # 实现具体的函数类
70. class Square(Function):
71.     def forward(self, x):
72.         return x ** 2
74.     def backward(self, gy):
75.         x = self.inputs[0].data                     # 从 inputs 中获取数据
76.         gx = 2 * x * gy
77.         return gx
79. class Add(Function):
80.     def forward(self, x0, x1):
81.         y = x0 + x1
82.         return y
84.     def backward(self, gy):
85.         return gy, gy                               # 对两个输入返回相同的梯度
87. # 定义便捷函数
88. def square(x):
89.     return Square()(x)
91. def add(x0, x1):
92.     return Add()(x0, x1)
94. # 定义 as_array 函数
95. def as_array(x):
96.     if np.isscalar(x):
97.         return np.array(x)
98.     return x
100. x = Variable(np.array(2.0))
101. a = square(x)
102. y = add(square(a) , square(a))
103. y.backward()
104. print(y.data)
105. print(x.grad)
106. '''
107. # 测试代码
108. x = Variable(np.array(2.0))
109. y = Variable(np.array(3.0))
110. z = add(square(x), square(y))
111. z.backward()
112. print(z.data)    # 输出结果: 13.0 (2^2 + 3^2 = 4 + 9 = 13)
113. print(x.grad)    # 输出梯度: 4.0 (dz/dx = 2 * 2 = 4)
114. print(y.grad)    # 输出梯度: 6.0 (dz/dy = 2 * 3 = 6)
115. '''

复制代码

运行效果：

下一章将会深入实践深度学习中的内存管理部分，把握代码技能