菜菜的深度学习笔记 | 基于Python的理论与实现（八）—＞简单层的实现

系列索引：菜菜的深度学习笔记 | 基于Python的理论与实现

我们以购买苹果和橘子的例子来了解一下计算图是如何应用的

（1）乘法层、加法层的实现

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

class MulLayer:
    def __init__(self): #初始化实例参数
        self.x = None
        self.y = None
        
    def forward(self,x,y): #接收x，y两个参数后相乘输出
        self.x = x
        self.y = y
        out = x*y
        
        return out
        
    def backward(self,dout):
        dx = dout*self.y
        dy = dout*self.x
        
        return dx,dy


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()
mul_tax_layer = MulLayer()
add_apple_orange_layer = AddLayer()


#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和forward的顺序相反

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


print("price:", int(price))
print("dApple:", dapple)
print("dApple_num:", int(dapple_num))
print("dOrange:", dorange)
print("dOrange_num:", int(dorange_num))
print("dTax:", dtax)

（2）激活函数层的实现

先来实现激活函数的ReLU层和Sigmoid层。

1.ReLU层

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
    

实例变量mask是由True/False构成的Numpy数组，他会把正向传播时的输入x的元素中小于等于0的地方保存为True。

x = np.array([[1.0,-0.5],[-2.0,3.0]])
print(x)

mask = (x<=0)
print(mask)

ReLU层的作用就像电路中的开关，正向传播时有电流通过的话就将开关设为ON，没有电流通过的话就OFF。反向传播时，开关为ON的话电流会直接通过，开关为OFF的话，则不会有电流通过。

2.Sigmoid层

具体关于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

基于Python的理论与实现 系列持续更新，欢迎点赞收藏＋关注

上一篇：菜菜的深度学习笔记 | 基于Python的理论与实现（七）—＞误差反向传播
下一篇：菜菜的深度学习笔记 | 基于Python的理论与实现（九）—＞Affine层的实现

本人水平有限，文章中不足之处欢迎下方👇评论区批评指正~

如果感觉对你有帮助，点个赞👍 支持一下吧 ~

不定期分享 有趣、有料、有营养内容，欢迎 订阅关注 🤝 我的博客 ，期待在这与你相遇 ~