从零学习pytorch——4.基础概念讲解及神经网络模块

从零学习pytorch——4.基础概念讲解及神经网络模块

在 PyTorch 中，nn.Module是构建神经网络模型的基础类。它提供了一种方便的方式来定义神经网络的结构，管理模型的参数，并实现前向传播和反向传播。通过继承nn.Module类，可以将神经网络的各个层定义为类的属性，然后在forward方法中定义数据的前向传播过程。
nn.Module会自动管理模型的参数，包括参数的初始化、梯度计算和更新等。这使得构建和训练神经网络变得更加简洁和高效。
神经网络是一种模仿人脑神经元连接的计算模型，由多层节点（神经元）组成，用于学习数据之间的复杂模式和关系。
神经网络通过调整神经元之间的连接权重来优化预测结果，这一过程涉及前向传播、损失计算、反向传播和参数更新。
神经网络的类型包括前馈神经网络、卷积神经网络（CNN）、循环神经网络（RNN）和长短期记忆网络（LSTM），它们在图像识别、语音处理、自然语言处理等多个领域都有广泛应用。

---

一、神经网络模块代码操作示例

简单全连接神经网络

import torch
import torch.nn as nn

class SimpleFCNet(nn.Module):
    def __init__(self):
        super(SimpleFCNet, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x


model = SimpleFCNet()
print(model)

这个例子中，我们定义了一个简单的全连接神经网络。在__init__方法中，我们定义了两个全连接层fc1和fc2，并在forward方法中定义了数据的前向传播过程，即先通过fc1层，然后经过 ReLU 激活函数，最后通过fc2层。

卷积神经网络（CNN）

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(16 * 16 * 16, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = self.pool(x)
        x = x.view(-1, 16 * 16 * 16)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x


model = SimpleCNN()
print(model)

这里我们定义了一个简单的卷积神经网络。在__init__方法中，我们定义了一个卷积层conv1、一个最大池化层pool和两个全连接层fc1和fc2。在forward方法中，我们按照卷积、激活、池化、展平、全连接、激活、全连接的顺序定义了数据的前向传播过程。

循环神经网络（RNN）

import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self):
        super(SimpleRNN, self).__init__()
        self.rnn = nn.RNN(10, 20, 1)
        self.fc = nn.Linear(20, 1)

    def forward(self, x):
        out, _ = self.rnn(x)
        out = self.fc(out[-1])
        return out


model = SimpleRNN()
print(model)

这里我们展示了如何定义一个简单的循环神经网络。在__init__方法中，我们定义了一个 RNN 层和一个全连接层。在forward方法中，我们将输入数据传入 RNN 层，然后取最后一个时间步的输出，通过全连接层得到最终输出。

二、实战案例：图像分类中的神经网络模块应用

我们将使用 PyTorch 的nn.Module构建一个卷积神经网络来对 CIFAR-10 数据集进行图像分类。CIFAR-10 数据集包含 10 个不同类别的 60000 张彩色图像，每张图像大小为 32x32 像素。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载CIFAR-10数据集
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

# 定义卷积神经网络模型
class CIFAR10CNN(nn.Module):
    def __init__(self):
        super(CIFAR10CNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(32 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = self.pool(x)
        x = torch.relu(self.conv2(x))
        x = self.pool(x)
        x = x.view(-1, 32 * 8 * 8)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x


model = CIFAR10CNN()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}')

# 测试模型
correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')

在这个案例中，首先对 CIFAR-10 数据集进行了预处理，并将其加载为数据加载器。然后定义了一个卷积神经网络模型CIFAR10CNN，并在模型中定义了卷积层、池化层和全连接层。接着定义了损失函数（交叉熵损失）和优化器（Adam）。在训练过程中，通过前向传播计算预测值和损失，然后使用backward()方法进行反向传播计算梯度，最后使用优化器根据梯度更新模型参数。训练完成后，我们在测试集上对模型进行了测试，计算了模型的准确率。