线性层和其它层的介绍

教学视频链接：神经网络-线性层及其他层介绍_哔哩哔哩_bilibili

 正则化层（Normalization Layers）

在 torch.nn 中，Normalization Layers 主要用于对输入数据进行标准化或归一化，以帮助模型的训练和收敛。这些层通常用于深度学习模型中，特别是在卷积神经网络（CNN）和递归神经网络（RNN）等结构中。

优点：可以加快神经网络的训练速度。

这个使用得不是很多。还是放一个官方网址：

BatchNorm2d — PyTorch 2.4 documentation

torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None) 

在它的众多参数中，一般只有num_features需要我们手动设置，其他默认即可。 

# With Learnable Parameters
m = nn.BatchNorm2d(100)


# Without Learnable Parameters(第一个参数与数据集的C相同)
m = nn.BatchNorm2d(100, affine=False)

#以下四个参数分别是(N,C,H,W)
input = torch.randn(20, 100, 35, 45)
output = m(input)

循环层（Recurrent Layers）

Recurrent Layers（循环层）指的是用于处理序列数据的神经网络层，主要是循环神经网络（RNN）及其变体。这些层允许模型在处理序列数据时保持状态或记忆，以便有效地捕捉序列中的长期依赖关系。

这个实际上是一种特定的层，用到的地方比较少。

笔者还没有学到循环神经网络，就先略过了，什么时候需要再来补。

变换层（Transform Layers）

Transform Layers（变换层）通常指的是一类用于对输入数据进行变换或映射的层次结构，它们在神经网络中起到了不同的作用和功能。这些层有时候也可以称为逐元素操作层或者非线性激活函数层，它们的设计目的是为了引入模型需要的非线性特性。

这个也使用得比较少。

线性层（Linear Layers）

Linear Layers（线性层）在 PyTorch 中属于神经网络的基本组成部分之一，也称为全连接层或仿射变换层。它们的作用是将输入张量与权重矩阵相乘，并加上一个偏置向量，从而实现对输入数据的线性变换。

这个使用的很广泛。官方网址：Linear — PyTorch 2.4 documentation

torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None) 

 对照着上面的函数基本介绍和上面所示的这幅图，我们来简单讲解一下函数的参数都是什么。

从图上不难看出，左中右分别是输入层、中间层（隐藏层）和输出层。

• in_features：指输入层的特征个数。即图中的d。
• out_features：指中间层的特征个数。即图中的L。
• bias：即偏置项，这个参数用于说明，在神经网络训练过程中，是否要加入偏置项b。

from torch import nn
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
dataset=torchvision.datasets.CIFAR10("../dataset",train=False,download=True,transform=torchvision.transforms.ToTensor())
dataloader=DataLoader(dataset,batch_size=64,drop_last=True)
class MyNn(nn.Module):
    def __init__(self) :
        super().__init__()
        self.lenear1=nn.Linear(196608,10)

    def forward(self,input):
        return self.lenear1(input)

mynn=MyNn()
for data in dataloader:
    imgs,targets=data
    
    output=torch.reshape(imgs,(1,1,1,-1))
    print(output.shape)
    output=mynn(output)
    print(output.shape)

    

随机失活层（Dropout Layers）

Dropout 是一种常用的正则化技术，主要用于减少神经网络模型的过拟合现象。 使用这个，会随机地把输入数据中的某些元素置为0，我们可以指定随机的概率，由此来防止过拟合。

搭建小实战和sequencial的使用

先把Sequrecial的官方网址放在这里：

Sequential — PyTorch 2.4 documentation

 CIFAR-10 简介

我们之前有一直使用CIFAR-10数据集，那么这个小实战就还是使用这个来进行分类。CIFAR-10中的‘10’代表的是10个类别 。具体介绍可以参考这篇文章：

【神经网络与深度学习】CIFAR10数据集介绍，并使用卷积神经网络训练图像分类模型——[附完整训练代码]_cifar-10-CSDN博客

 下图是训练该分类模型的示例图。可以看出它的运作方式就是先卷积再池化再卷积再池化......最后摊平成一维数据再输出。

其中我要单独拿出来说的是第一步卷积的过程，图上可以看到，输入(Input)是3@32*32，这个的意思其实是3通道，每通道32*32像素（也就是32*32的数据），而经过第一次卷积后，它的通道数增加了：32@32*32。为什么会这样？其实在于它使用的卷积核，图中只标明了这是一个5*5的卷积核，并没有说它的通道数，实际上，这里应该是一个三通道的5*5卷积核，在第一次卷积处理过程中，这样的卷积核一共有32个。每一个卷积核做运算后得到一通道的32*32的输出，一共32个输出“平面”，这才使得第一次卷积的结果成为了32@32*32。

今天我们就来实现这个模型。

模型实现

这一部分要做的笔记就太多了。

把视频放在这里：神经网络-搭建小实战和Sequential的使用_哔哩哔哩_bilibili

 再把图放在这里一遍：

 在搭建网络过程中，有一些参数是涉及到计算的。

比如说刚刚说过的卷积层，再把卷积函数放一下：

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1,

 groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

可以看到，我们需要设置的参数有：in_channels,out_channels,kernel_size等等。我们需要注意官网上所给出的计算公式：

 其他几个卷积层的计算公式类似，建议看不懂过程的去看视频。

由此我们可以得出所需要设置的参数，开始搭建网络了。

from torch import nn
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
#dataset=torchvision.datasets.CIFAR10("../dataset",train=False,download=True,transform=torchvision.transforms.ToTensor())
#dataloader=DataLoader(dataset,batch_size=64,drop_last=True)
class MyNn(nn.Module):
    def __init__(self) :
        super().__init__()
        # self.conv1=nn.Conv2d(3,32,5,padding=2)
        # self.maxpool1=nn.MaxPool2d(2)
        # self.conv2=nn.Conv2d(32,32,5,padding=2)
        # self.maxpool2=nn.MaxPool2d(2)
        # self.conv3=nn.Conv2d(32,64,5,padding=2)
        # self.maxpool3=nn.MaxPool2d(2)
        # self.flatten=nn.Flatten()
        # self.linear1=nn.Linear(1024,64)
        # self.linear2=nn.Linear(64,10)
        '''使用Sequential可以简化代码'''
        self.model1=nn.Sequential(
            nn.Conv2d(3,32,5,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,32,5,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024,64),
            nn.Linear(64,10)
        )


    def forward(self,x):
        # x=self.conv1(x)
        # x=self.maxpool1(x)
        # x=self.conv2(x)
        # x=self.maxpool2(x)
        # x=self.conv3(x)
        # x=self.maxpool3(x)
        # x=self.flatten(x)
        # x=self.linear1(x)
        # x=self.linear2(x)
        x=self.model1(x)
        return x

'''
检验网络是否设置正确：
'''
mynn=MyNn()
input=torch.ones((64,3,32,32))
output=mynn(input)
writer=SummaryWriter('Logs')
writer.add_graph(mynn,input)
writer.close()

最后想说的是writer.add_graph()的使用，不得不说tensorboard真的太强大了：

 我们可以使用它来查询训练的每一步过程。