深度学习层和块

层和块的概念

        层： 接收一组输入，生成一组输出，有一组可调整的参数Parameter 进行描述，前一层的输出是下一层的输入，参数通过从下一层反向传播的信号进行更新。
        为了实现更复杂的网络，引入了块的概念，将一层或几层神经网络进行组合形成一个块，这个块提供一定的功能。块一般由类class进行表示，且每个class都必须有个由输入到输出的正向传播函数，即

#forward函数必须有输入x以及输出y，
def forward(self,x)

    #计算其输出关于输入的梯度，可通过其反向传播函数进行访问，反向传播过程在后台自动计算
    #存储和访问正向传播需要的参数
   
    return y

顺序块，Sequential是一个容器，它的设计就是为了把其他的块串起来。比如写一个自定义的顺序快:

class MySequential(nn.Module):
    def __init__(self,*args):
        super().__init__()
        for block in args:
            self._modules[block] = block
    def forword(self,x):
        for block in self._modules.values():
            x = block(x)
        return x
#nn.Linear(in,out)是全连接层
net = MySequential(nn.Linear(20,256),nn.ReLu(),nn.Linear(256,10))
net(x)

如何构建自定义层

第一层，不带参数的层

#不带参数的层
import torch
import torch.nn as nn
import torch.nn.functional as F


class CenteredLayer(nn.Module):
    def __init__(self):
        super().__init__()
        
    def forward(self,X):
        return X-X.mean()


#验证
#先实例化layer
layer = CenteredLayer()
#输入x
layer(torch.FloatTensor([1,2,3,4,5]))
#返回所有元素均值的差值

tensor([-2., -1.,  0.,  1.,  2.]) 

将上述定义的层组成更复杂的模块

#将上述定义的层组合成更复杂一些的块模型中
#由两个组件进行连接，一个全连接层，一个上述定义的不带参数的层
net = nn.Sequential(nn.Linear(8,128),CenteredLayer())


#实例化该net模型
Y = net(torch.rand(4,8))
Y.mean()
Y.shape

 torch.Size([4, 128])

 第二层，带参数的层

#带参数的层
class MyLinear(nn.Module):
    #在__init__中定义模型需要的参数，在forward函数中进行计算
    def __init__(self,in_units,units):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(in_units,units))
        self.bias = nn.Parameter(torch.randn(units,))
    #matmul是矩阵相乘的函数，linear表示为X*W+b,最后在return中加上一个ReLu函数（激活函数）
    def forward(self,X):
        linear = torch.matmul(X,self.weight.data)+self.bias.data
        return F.relu(linear)


#对上述带参数的模型进行实例化
linear = MyLinear(5,3)
linear.weight     #查看其参数矩阵

Parameter containing:
tensor([[ 0.8715,  1.1652, -0.8875],
        [ 0.2570,  0.4041, -0.6611],
        [-1.6138,  0.4193, -0.3076],
        [ 1.4776,  0.6923, -0.7133],
        [ 1.3805, -0.0550, -1.7327]], requires_grad=True)

使用自定义的层构建模型

#使用自定义的层构建模型Linear(in_channel,out_channel)
net = nn.Sequential(MyLinear(64,8),MyLinear(8,1))
a = net(torch.rand(2,64))#输入的是2*64，由上述输入输出形状得到
a.shape

torch.Size([2, 1])