神经网络里的层和块（Layers and blocks in neural networks）

层（Layers）：在神经网络中，一个层通常指的是神经网络中的一个处理单元。如上图全连接层中的隐藏层。

块（Blocks）：块是由多个层组成的结构。

我们可以回忆我们一个基本的线性回归的流程，一个块首先由多个层组成，可以是全连接，卷积层等，还可以包括激活函数，正则化以及一些定制的功能。其目的就是将特定功能打包，实现可重复，定制化，模块化的应用，使得神经网路更简洁清晰。

图上可以看出一个块相当于一个很多变化的层，可以把它想象成一个复合函数。

而层中的代码逻辑则是：

    # 继承nn.Module

    #初始化方法

    #向前传播

下面有详细代码演示，代码部分为《动手学深度学习》内容：

在pytorch中，有一个特殊的顺序块nn.Sequential()，通过使用nn.Sequential() ，可以快速创建一个序列化的模块，其中每个子模块的输出自动成为下一个模块的输入。在python中，一个块可以用一个类来表示，如下简单模仿一下nn.Sequential()的功能。

import torch
from torch import nn

#定义Sequential类
class Sequential(nn.Module):
    # 定义子类的构造函数，初始化所有的模型
    # *args是一个可变参数，意味着你可以传入任意数量的参数
    def __init__(self, *args):
        #继承父类
        super().__init__()
        for idx, module in enumerate(args):
            # self._modules 是 nn.Module 中用于存储子模块的属性。将每个传入的模块按照它们被传入的顺序存储起来，使用它们的索引作为键。
            self._modules[str(idx)] = module
    
    def forward(self, X):
        for block in self._modules.values():
            X = block(X)
        return X

通常，在我们深入学习深度学习后，通常需要自己定义一些块用以实现某些特殊的功能，例如有如下块用来实现固定优化过程中的常数参数（constant patameter)：

#固定优化过程中的常数参数
class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__():
        # 固定参数所以不需要求梯度
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        X = self.linear(X)
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        X = self.linear(X)
        # 可以在块中加入控制流实现定制化处理,例如：
        while X.abs().sum() > 1:
            X /= 2
        return X
        
    

在块中，我们也可以加入一个或多个块，例如：

# 定义一个包含nn.Sequential的块
class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
                                 nn.Linear(64, 32), nn.ReLU())
        self.linear = nn.Linear(32, 16)

    def forward(self, X):
        return self.linear(self.net(X))

最后，我们可以将我们定义的块混搭起来，用nn.Sequential连接：

chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(x)

综上代码及图例可以看出，一个块包括基本的内部处理：

        1.接收数据，进行特定的操作，包括初始化，激活函数，正则化，及特定操作。

        2.向前传播。

        3.数据输出。

        4.参数管理。

        5.反向传播支持。（包含可训练层如self.linear）

以上就是一个块的基本逻辑。