【python】由a = a + b与a += b引发的bug——对待内存地址要慎重

最近在做模式识别课程的作业（只用numpy搭建一个全连接神经网络来训练mnist），遇到一个神奇的问题让我debug了好久。鉴于我还是个python小白，在此记录一下。

1. 问题概述

问题是由优化器中的这两行代码引起的：

param = param - lr * grad
param -= lr * grad

• 使用 a = a - b 的形式更新权值的时候发现网络的参数没有更新
• 使用 a -= b 的形式却可以更新

查了一下，原因是：

• 对于可变对象类型作为参数传递给函数的时候实际上是引用传递
• 对于可变对象类型：
  • a = a - b的赋值操作会产生一个新的对象赋给 a ，此时 a 的内存地址是会发生变化的
  • a -= b 的赋值操作不会更改 a 的内存地址
• 对于不可变对象类型：
  • 两种操作都会改变原有的地址

而param是np.array类型的，是可变对象，因此地址会改变
举个例子：

class A:
	def __init__(self,a,b):
		self.a = a
		self.b = b
	def print_something(self):
		print('a in class A = ', self.a)
		print('b in class A = ', self.b)

def function(a,b):
	a += 1
	b = b + 1

if __name__ == '__main__':
	a = np.array([1,2])
	b = np.array([1,2])
	X = A(a,b)
	function(a,b)
	X.print_something()

打印的结果：
a in class A =  [2 3]
b in class A =  [1 2]

在调用__init__的时候，a和b分别把它们自己的地址传给了self.a和self.b，在调用function(a,b)的时候a的新值仍然存放在自己的旧地址中，而b的新值存放在了新的地址中，而self.a和self.b仍然指向旧地址，因此就导致了self.a更新了而self.b没有更新。

---

2. 结论

• 对于可变对象类型作为参数传递给函数的时候实际上是引用传递
• 对于可变对象类型：
  • a = a - b的赋值操作会产生一个新的对象赋给 a ，此时 a 的内存地址是会发生变化的
  • a -= b 的赋值操作不会更改 a 的内存地址
• 对于不可变对象类型：
  • 两种操作都会改变原有的地址

总的来说原因就在于参数更新后内存地址对不上

---

3. 相关代码与详细问题

这里贴上问题相关的代码方便理解这一次的问题所在：

1.全连接层

class FC():
    def __init__(self, W, b):
        self.W = W  # 权重矩阵-2d
        self.b = b  # 偏置向量-1d
        self.x = None  # 记住神经元的前馈时的输入，用于反向传播-2d(一个是batch维度，一个是数据维度)
        self.dW = None  # 权重梯度矩阵-2d
        self.db = None  # 偏置梯度向量-1d

    def forward(self, x):
        print('inside FClayer ', self.b)
        self.x = x
        out = np.dot(self.x, self.W) + self.b
        # out.shape = (batchsize, n) n为该FC层神经元个数（即b的长度）
        return out

    def backward(self, dout):
        # dout是传播到本层的梯度，对应于delta^l，shape对应于本层输出的shape
        # dx是本层往下一层传的梯度，对应于delta^l-1
        # dout.shape = (batchsize, n)
        # dx.shape = (batchsize, m) m为l-1层的神经元个数（即self.x的第二个维度）
        self.dW = np.matmul(self.x.T, dout)  # 两个矩阵相乘，结果正好是各梯度针对batch做求和
        self.db = np.sum(dout, axis=0)  # 偏置的梯度对batch求和  注意此处不用除以batchsize，因为该平均操作在代价函数那里已经平均了
        dx = np.matmul(dout, self.W.T)
        return dx

2. 全连接神经网络

class FCnet2():  # 2层全连接层的网络
    def __init__(self, hidden, weight_init_std=0.01):
        self.params = {}
        self.params['FC1_W'] = np.random.randn(784, hidden) * weight_init_std
        self.params['FC1_b'] = np.zeros(hidden)
        self.params['FC2_W'] = np.random.randn(hidden, 10) * weight_init_std
        self.params['FC2_b'] = np.zeros(10)

        self.Layers = OrderedDict()  # 有序字典对象，用来存放网络结构
        
        self.Layers['FC1'] = FC(self.params['FC1_W'], self.params['FC1_b'])
        self.Layers['ReLU1'] = ReLU()
        self.Layers['FC2'] = FC(self.params['FC2_W'], self.params['FC2_b'])
        
        self.Layers['softmax'] = Softmax()
        self.CostFunc = CrossEntropyCost()  # 定义代价函数

    def predict(self, x):
        for layer in self.Layers.values():
            x = layer.forward(x)
        return x

    def loss(self, x, label):
        y = self.predict(x)
        loss = self.CostFunc.forward(y, label)
        return loss

    def accuracy(self, x, label):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        label = np.argmax(label, axis=1)
        acc = np.sum(y==label) / y.shape[0]  # 计算整组样本中有多少组是分类正确的，计算正确率
        return acc

    def gradient(self, x, label):  # 输出梯度值，用于优化算法来更新权重
        grads = {}
        loss = self.loss(x, label)

        dout = self.CostFunc.backward()
        layers = list(self.Layers.values())
        layers.reverse()  # 反过来用于反向传播
        for layer in layers:
            dout = layer.backward(dout)
        grads['FC1_W'] = self.Layers['FC1'].dW
        grads['FC1_b'] = self.Layers['FC1'].db
        grads['FC2_W'] = self.Layers['FC2'].dW
        grads['FC2_b'] = self.Layers['FC2'].db
        return grads, loss

3. SGD优化器

class SGD():
    def __init__(self, lr=0.01):
        self.lr = lr

    def update(self, params, grads):
        for key in params.keys():
            params[key] -= grads[key] * self.lr 
            # params[key] = params[key] - grads[key] * self.lr

注意：此处传进来的params是上述的FCnet2的self.params字典

FCnet2()这个类在初始化的时候会创建字典self.params用来存储每一层的参数。
比如：
self.params['FC1_W'] = np.random.randn(784, hidden) * weight_init_std self.params['FC1_b'] = np.zeros(hidden)

然后再创建字典self.Layers来存储每一层的对象。
比如：
self.Layers['FC1'] = FC(self.params['FC1_W'], self.params['FC1_b'])

这里在初始化网络里的FC层的时候，实际上是调用到了FC()里的__init__(self,W,b)这个初始化函数，FC.W和FC.b就指向了FCnet2.params['FC1_W']和FCnet2.params['FC1_b']的地址。

• 当优化器采用的是+=的操作时FCnet2.params['FC1_W']地址没有变化，FC.W读取以前的地址时就能读取到新的值，网络层内的权重得以更新
• 当优化器采用的是=+的操作时FCnet2.params['FC1_W']的地址变化了，但是FC.W仍然只能读取旧地址，自然就读取不到新的值，网络层内的权重无法更新

这就会出现这样的一种情况：

• FCnet2类内的self.params随着迭代确实更新了
• FC类内的self.W和self.b没有读取到新的更新值——导致无法更新
• FCnet2类内存放梯度的grads每一次都相同——同样说明了FC在每一次forward的时候权值都是一样的（如果有一丁点不相同都不会导致grads一样）

这个实际问题抽象出来就是一开始提出的那个例子，问题的原因就在于参数更新后内存地址对不上。