下面把构建神经网络的“层”实现为一个类。这里所说的“层”是神经网络中功能的单位。

下面先从一些简单的层开始介绍

乘法层的实现

层的实现中有两个共通的方法(接口)forward()和backward()。
forward() 对应正向传播
backward() 对应反向传播

现在来实现乘法层。看下面代码

class MulLayer:
	def __init__(self):
		self.x = None
		self.y = None
	
	def forward(self, x, y):
		self.x = x
		self.y = y
		out = x * y
		return out

	def backward(self, dout):
		dx = dout*self.y # 翻转x和y
		dy = dout*self.x

		return dx,dy

backward()将从上游传来的导数(dout)乘以正向传播的翻转值，然后传给下游。

下面就使用MulLayer实现前面的购买的例子(2个苹果和消费税)。看图：

通过乘乘法层，上图的正向传播可以像下面这样实现：

apple = 100
apple_num = 2
tax = 1.1

# layer
mul_apple_layer = MulLayer()
mul_tax_layer = MulLayer()

#forward
apple_price = mul_apple_layer.forward(apple, apple_num)
price = mul_tax_layer.forward(apple_price ,tax)
print(price)

求各个变量的导数可由backward()求出

#backward
dprice = 1
dapple_price, dtax = mul_tax_layer.backward(dprice)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)

print(dapple, dapple_num, dtax)

此外，要注意backward()的参数中需要输入“关于正向传播时的输出变量的导数”。

加法层的实现

下面来实现加法节点的加法层

class AddLayer:
	def __init__(self):
		pass

	def forward(self, x, y):
		out = x+y
		return out

	def backward(self, dout):
		dx = dout*1
		dy = dout*1
		return dx,dy

下面使用加法层和乘法层，实现下图的例子：

实现代码如下：

apple = 100
apple_num = 2
orange = 150
orange_num = 3
tax = 1.1

# layer
mul_apple_layer = MulLayer()
mul_orange_layer = MulLayer()
add_apple_orange_layer = AddLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple, apple_num)
orange_price = mul_orange_layer.forward(orange, orange_num)
all_price = add_apple_orange_layer.forward(apple_price, orange_price)
price = mul_tax_layer.forward(all_price, tax)

#backward
dprice = 1
dall_price, dtax = mul_tax_layer.backward(dprice)
dapple_price, dorange_price = add_apple_orange_layer.backward(dall_price)
dorange, dorange_num = nul_orange_layer.backward(dorange_price)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)

print(price)
print(dapple_num, dapple, dorange, dorange_num, dtax)

综上，计算图中层的实现非常简单，使用这些层可以进行复杂的导数计算。

激活函数层的实现

这里把构成神经网络的层实现为一个类。先来实现激活函数的ReLU层和Sigmoid层。

现在来实现ReLU层。在神经网络的层的实现中，一般假定 forward()和tackerd0 的参数是NumPy数组。代码如下：

class Relu:
	def __init__(self):
		self.mask = None

	def forward(self, x):
		self.mask = (x <= 0)
		out = x.copy()
		out[self.mask] = 0

		return out

	def backward(self, dout):
		dout[self.mask] = 0
		dx = dout
		
		return dx
	

Relu类有实例变量mask。这个变量mask是由True/False构成的NumPy数组，它会把正向传播时的输人x的元素中小于等于0的地方保存为True，其他地方(大于0的元素)保存为False。如下例所示，mask变量保存了由True/False构成的NumPy数组

>>> x= np.array( [[1.0,-0.5],[-2.0，3.0]] )
>>>print(x)
[[1. -0.5]
[-2、 3.]]
>>>mask=(x<=0)
>>>print(mask)
[[False True]
[True False]]

如果正向传播时的输入值小于等于0, 则反向传播的值为0,
反向传播中会使用正向传播时保存的mask，
将从上游传来的dout的mask中的元素为True的地方设为0。 (关键思路）

Sigmoid层

计算图表示的话，如下：

Sigmoid层包括反向传播的计算图如下：

上面可以简化为

这样通过对节点进行集约化，可以不用在意Sigmoid层中琐碎的细节，而只需要专注它的输入和输出

另外，该结果可以进一步整理如下：

下面用Python来实现Sigmoid层，代码如下：

class Sigmoid:
	def __init__(self):
		self.out = None

	def forward(self,x):
		out = 1 / (1+np.exp(-x))
		self.out = out
		return out

	def backward(self, dout):
		dx = dout * (1.0 - self.out)*self.out
		return dx