实现神经网络的任务在机器学习中是非常关键的，pytorch是当前非常常用的及强大的深度学习框架之一。在这里，我将详细讲解如何使用pytorch搭建神经网络，并提供两条示例说明。
准备工作
在开始搭建神经网络之前，需要先准备好环境及需要的库。以anaconda为例，可以通过以下指令来创建新环境及安装pytorch和torchvison：
conda create -n pytorch python=3.8
conda activate pytorch
conda install pytorch torchvision -c pytorch
1. 搭建神经网络
1.1 神经网络架构
神经网络的架构是搭建神经网络的重要组成部分。通常神经网络的架构包括输入层、隐藏层和输出层。通过pytorch的nn库我们可以方便地定义神经网络构架，下面是一个简单的示例：
import torch.nn as nn
class NeuralNetwork(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(NeuralNetwork, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.fc1 = nn.Linear(self.input_size, self.hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(self.hidden_size, self.output_size)
def forward(self, input):
hidden = self.fc1(input)
relu = self.relu(hidden)
output = self.fc2(relu)
return output
上面的代码是一个两层神经网络架构的示例，这里使用了两个全连接层（linear layers）和一个ReLU激活函数。首先在构造函数中定了神经网络的输入、隐藏和输出层，并使用nn.Linear创建了两个全连接层。接下来定义了一个ReLU激活函数，最后在forward函数中实现了对神经网络的向前传播。
1.2 损失函数
损失函数是评价神经网络的重要指标，通常我们使用L1、L2 loss和交叉熵等函数。Pytorch中利用nn库实现损失函数十分方便，下面是一个简单的MSE示例：
criterion = nn.MSELoss()
1.3 优化器
优化器的作用是更新神经网络中的参数，常用的有SGD、Adam等。在Pytorch中可以使用torch.optim库来创建优化器，下面是一个简单的Adam示例：
import torch.optim as optim
optimizer = optim.Adam(model.parameters(), lr=0.001)
在这里，我们使用Adam优化器来优化神经网络中的参数，学习率为0.001。
1.4 训练神经网络
搭建好神经网络架构后，需要训练神经网络。下面是一个基础的训练函数实现：
def train(model, optimizer, criterion, train_loader):
model.train()
for i, (inputs, labels) in enumerate(train_loader):
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
return loss.item()
在这个训练函数中，我们调用train_loader来迭代输入神经网络的数据，每次训练的时候都会在前向传播和反向传播之间使用优化器来更新神经网络中的参数。
2. 示例
2.1 MNIST手写数字数据集分类
这个示例中我们将使用Pytorch搭建一个能够对MNIST数据集中的手写数字进行分类的神经网络。首先，我们需要下载MNIST数据集，可以使用torchvison来方便地下载：
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)
在这段代码中，我们使用transforms.Compose来进行MNIST数据集预处理。通过将ToTensor()和Normalize()组合，我们将数据集转换成了Pytorch的Tensor格式。然后使用DataLoader函数来加载训练集和测试集，并设置每个batch的大小为64。
接下来，我们就可以利用上文中提到的方法来定义神经网络和训练模型了。我们选择一个两层卷积神经网络（CNN）的架构，并选择Adam优化器作为优化器：
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, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 4 * 4, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 4 * 4)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
num_epochs = 5
for epoch in range(num_epochs):
train_loss = train(net, optimizer, criterion, trainloader)
print("Epoch:{} loss:{}".format(epoch, train_loss))
当训练神经网络完成后，我们可以使用下面的代码来评估神经网络的性能：
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))
2.2 CIFAR-10图像分类
CIFAR-10是一个经典的图像分类数据集，可以通过torchvision直接下载得到。下面我们展示如何使用Pytorch搭建卷积神经网络对CIFAR-10数据集进行分类：
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
[transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32,padding=4),
transforms.ToTensor(),
transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=128,
shuffle=False, num_workers=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(3, 64, 5,padding=2)
self.pool = nn.MaxPool2d(2, 2)
self.drop1 = nn.Dropout(0.3)
self.conv2 = nn.Conv2d(64, 128, 5,padding=2)
self.drop2 = nn.Dropout(0.4)
self.fc1 = nn.Linear(128 * 8 * 8, 512)
self.drop3 = nn.Dropout(0.5)
self.fc2 = nn.Linear(512, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = self.pool(x)
x = self.drop1(x)
x = F.relu(self.conv2(x))
x = self.pool(x)
x = self.drop2(x)
x = x.view(-1, 128 * 8 * 8)
x = F.relu(self.fc1(x))
x = self.drop3(x)
x = self.fc2(x)
return x
net = Net()
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
num_epochs = 15
for epoch in range(num_epochs):
train_loss = train(net, optimizer, criterion, trainloader)
print("Epoch:{} loss:{}".format(epoch, train_loss))
同样地，我们使用训练好的神经网络模型来对CIFAR-10数据集进行分类
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))
总结
通过上面这两个示例，我们成功地使用Pytorch实现了基本的神经网络训练和分类任务。实际上，我们可以使用更加复杂的神经网络架构，并且能够基于这些示例来进行更加高级的深度学习应用。
本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：pytorch 搭建神经网路的实现 - Python技术站
微信扫一扫 
支付宝扫一扫 