【深度学习】PyTorch搭建基础神经网络（超详细）

引言：

神经网络作为人工智能的重要组成部分，在图像处理、自然语言处理、语音识别、机器翻译等领域具有广泛的应用。本文将详细介绍如何搭建简单的神经网络框架并进行训练。在搭建神经网络前，对数据集的下载和处理的详细可以看我的这篇博客：（神经网络模型（最细的手写字识别案例）_AI_dataloads的博客-CSDN博客）

代码展示：

首先定义一个名为NeuralNetwork的类，它继承了PyTorch框架的nn.Module类，用于创建神经网络。 接下来部分是类的构造函数__init__()，用于初始化神经网络的各个层。在这个类中，初始化了以下层：

• flatten：一个将输入展平的层。
• hidden1：第一个隐藏层，输入大小为28x28（图像大小），输出大小为128。
• hidden2：第二个隐藏层，输入大小为128，输出大小为128。
• hidden3：第三个隐藏层，输入大小为128，输出大小为64。
• out：输出层，输入大小为64，输出大小为10（类别数）。

# 定义一个名为NeuralNetwork的类，它继承了PyTorch框架的nn.Module类，用于创建神经网络。
class NeuralNetwork(nn.Module):
    def __init__(self):
        # 继承父类nn.Module的方法和属性
        super(NeuralNetwork, self).__init__()
        # 数据进行展平操作
        self.flatten=nn.Flatten()
        # 定义一层线性神经网络
        self.hidden1=nn.Linear(28*28,128)
        self.hidden2=nn.Linear(128,128)
        self.hidden3=nn.Linear(128,64)
        self.out=nn.Linear(64,10)

这部分定义了前向传播方法forward()，通过前向传播计算输入数据x的输出。首先输入的数据先通过flatten层展平，然后依次经过隐藏层和激活函数进行线性变换和非线性处理。最后经过输出层输出预测结果x。（注意这个函数也是定义在NeuralNetwork之中的。）

   def forward(self,x):
        # 对输入数据进行展平操作
        x=self.flatten(x)
        # 将数据传入第一层线性神经网络
        x=self.hidden1(x)
        # 对神经网络的输出应用ReLU激活函数
        x=torch.relu(x)
        x=self.hidden2(x)
        # 对神经网络的输出应用sigmoid激活函数
        x=torch.sigmoid(x)
        x=self.hidden3(x)
        x=torch.relu(x)
        # 将数据传入输出层
        x=self.out(x)
        # 最后经过输出层输出预测结果x
        return x

这行代码创建了一个model的神经网络模型实例，并将其移动到特定的设备（我这里使用的是GPU）上进行计算。如何查看自己的torch设备（device）可以查看这篇博客：神经网络模型（最细的手写字识别案例）_AI_dataloads的博客-CSDN博客

model=NeuralNetwork().to(device)

这行代码创建了一个CrossEntropyLoss（交叉熵损失函数）的实例，用作损失函数。想要了解神经网络中的损失函数可以看我的这篇博客：pytorch中损失函数的使用_AI_dataloads的博客-CSDN博客

#交叉熵损失函数
loss_fn=nn.CrossEntropyLoss()

这行代码创建了一个Adam优化器的实例，将模型参数和学习率作为参数传入。想了解优化器的定义可以参考我的这篇博客：pytorch中损失函数的使用_AI_dataloads的博客-CSDN博客

# model.parameters()用于获取模型的所有参数。这些参数包括权重和偏差等
# 它们都是Tensor类型的，是神经网络的重要组成部分
optimizer=torch.optim.Adam(model.parameters(),lr=0.005)

这行代码定义了一个名为train的函数，用于进行训练。函数接受训练数据、模型、损失函数和优化器作为输入参数。

'''定义训练函数'''
def train(dataloader,model,loss_fn,optimizer):
    # 设置模型为训练模式
    model.train()
    # 记录优化次数
    num=1
    # 遍历数据加载器中的每一个数据批次。
    for X,y in dataloader:
        X,y=X.to(device),y.to(device)
        # 自动初始化权值w
        pred=model.forward(X)
        loss=loss_fn(pred,y) # 计算损失值
        # 将优化器的梯度缓存清零
        optimizer.zero_grad()
        # 执行反向传播计算梯度
        loss.backward()
        # 并通过优化器更新模型参数
        optimizer.step()
        # 将损失值转换为标量
        loss_value=loss.item()
        #将此次损失值打印出来
        print(f'loss:{loss_value},[numbes]:{num}')
        #增加计数器num
        num+=1

这行代码调用train函数来开始模型的训练。它传入训练数据、模型、损失函数和优化器，并执行训练过程。（注意训练前要先获取dataloader，详细可以参考我的博客：PyTorch DataLoader详解：如何高效加载和处理大规模数据集？_AI_dataloads的博客-CSDN博客

#调用函数train(),传入训练数据，神经网络模型，损失函数和优化算法
train(train_dataloader,model,loss_fn,optimizer)

下面是运行后的结果：可以看出一共进行了938次，并展示了每一次的损失值

下面是完整代码展示：

'''定义神经网络'''
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten=nn.Flatten()
        self.hidden1=nn.Linear(28*28,128)
        self.hidden2=nn.Linear(128,128)
        self.hidden3=nn.Linear(128,64)
        self.out=nn.Linear(64,10)
    def forward(self,x):
        x=self.flatten(x)
        x=self.hidden1(x)
        x=torch.relu(x)
        x=self.hidden2(x)
        x=torch.sigmoid(x)
        x=self.hidden3(x)
        x=torch.relu(x)
        x=self.out(x)
        return x

model=NeuralNetwork().to(device)
print(model)

'''建立损失函数和优化算法'''
#交叉熵损失函数
loss_fn=nn.CrossEntropyLoss()
# 优化算法为随机梯度算法/Adam优化算法
optimizer=torch.optim.Adam(model.parameters(),lr=0.005)

'''定义训练函数'''
def train(dataloader,model,loss_fn,optimizer):
    model.train()
    # 记录优化次数
    num=1
    for X,y in dataloader:
        X,y=X.to(device),y.to(device)
        # 自动初始化权值w
        pred=model.forward(X)
        loss=loss_fn(pred,y) # 计算损失值
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        loss_value=loss.item()
        print(f'loss:{loss_value},[numbes]:{num}')
        num+=1

train(train_dataloader,model,loss_fn,optimizer)