Pytorch 搭建分类回归神经网络并用GPU进行加速的例

1. 简介

在计算机视觉及语音处理领域，神经网络是一个重要的工具。在深度学习中，我们可以训练一个神经网络来解决分类或回归问题。最近，Pytorch成为了深度学习领域的重要工具箱。

2. 神经网络分类问题

2.1 数据准备

首先，我们需要准备数据，以MNIST手写数字数据集为例。下面是数据预处理：

import torch

import torchvision
import torchvision.transforms as transforms
# 准备数据并转换
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5,), (0.5,))])
trainset = torchvision.datasets.MNIST(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)
testset = torchvision.datasets.MNIST(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64,
                                         shuffle=False, num_workers=2)

其中，我们将下载的MNIST数据集放到当前目录下的./data文件夹中，通过transforms.Compose函数将数据预处理。使用torchvision.datasets.MNIST函数准备数据，并使用torch.utils.data.DataLoader函数加载数据。

2.2 简单分类网络

接下来，我们可以定义一个简单的分类网络来解决手写数字的分类问题。下面是示例代码：

import torch.nn as nn

import torch.nn.functional as F
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.dropout1 = nn.Dropout2d(0.25)
        self.dropout2 = nn.Dropout2d(0.5)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)
    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
        return output
net = Net()

在这个网络中，我们使用两个卷积层和两个全连接层。其中，使用了ReLU激活函数和dropout层。最后，我们使用了log_softmax函数作为输出层激活函数。

2.3 模型的训练

现在，我们需要定义训练和测试过程。下面是示例代码：

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:    
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

在这个例子中，我们使用交叉熵损失作为损失函数，随机梯度下降（SGD）算法作为优化算法，训练数据集进行了10个epoch的训练。运行代码之后，您将看到每个epoch的平均损失值。

2.4 测试模型

最后，我们可以测试模型来评估其性能。下面是示例代码：

correct = 0

total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

这段代码将统计训练集中被正确分类的样本数，并最终计算出网络的整体准确率。

3. 神经网络回归问题

3.1 数据准备

对于回归问题，我们需要创建一个数据集并对其进行预处理。下面是示例代码：

import matplotlib.pyplot as plt

import numpy as np
# 创建数据集
x_train = np.random.rand(100, 1)
y_train = x_train * np.sin(2 * np.pi * x_train) + np.random.randn(100, 1) * 0.4
# 数据可视化
plt.scatter(x_train, y_train)
plt.show()

在这个例子中，我们创建了一个简单的正弦函数并加入了一些噪声，然后使用matplotlib库将数据可视化。

3.2 简单回归网络

接下来，我们可以定义一个简单的回归网络来学习这个非线性函数。下面是示例代码：

class RegNet(nn.Module):

    def __init__(self):
        super(RegNet, self).__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 1)
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x
net = RegNet()

这个网络有一个全连接层和一个输出层。请注意，我们没有使用任何激活函数。

3.3 模型的训练

现在，我们需要定义训练和测试过程。下面是示例代码：

criterion = nn.MSELoss()

optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9)
for epoch in range(500):
    running_loss = 0.0
    for i in range(len(x_train)):
        inputs = torch.Tensor([[x_train[i]]])
        labels = torch.Tensor([[y_train[i]]])
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
print('Finished Training') 

在这个例子中，我们使用平均平方误差（MSE）作为损失函数，随机梯度下降（SGD）算法作为优化算法，训练模型500次。运行代码之后，程序将输出“Finished Training”。

3.4 测试模型

最后，我们可以测试模型来评估其性能。下面是示例代码：

x_test = np.arange(0, 1, 0.01).reshape(-1, 1)

y_test = net(torch.Tensor(x_test)).data.numpy()
plt.scatter(x_train, y_train)
plt.plot(x_test, y_test, color='r')
plt.show()

这段代码将提供一个机会来测试模型学习效果，并将输出模型拟合数据的可视化图形。

4. 使用GPU进行加速

Pytorch还可以利用GPU来进行运算，这样可以加快计算速度。下面是一个简单的例子，说明如何将代码放到GPU上：

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

print(device)
net.to(device)
inputs, labels = data[0].to(device), data[1].to(device)

首先，我们需要检查可用的设备。然后我们可以将模型放到GPU上。同样，我们要将我们的输入数据移到GPU上。

5. 总结

神经网络是一个强大的工具，可用于解决分类和回归问题。Pytorch是一个流行的深度学习库，它使神经网络的搭建和训练变得容易。在这篇文章中，我们介绍了分类和回归问题的一些基本概念，并提供了可重现的例子。此外，我们还提供了有关如何使用GPU加速代码的简单介绍。