小伙伴好，最近想要认真学习一波pytorch，打算通过pytorch去构建一系列的网络模型，包括CNN、LSTM、Transform等，后续都会进行搭建。一个不断学习的小菜鸡，也希望有问题小伙伴能指出。
MINST数据集是手写数字的识别，图片尺寸为(28,28,1)，标签为数字的类别。
1、加载数据
本文这次主要是对MNIST数据集进行测试。利用pytorch加载数据的方法如下：
利用datasets中可加载不同的数据集，本次选用MNIST数据集
from torchvision import datasets, transforms
batch_size = 128
加载数据
def load_data():
# 下载数据
train_data = datasets.MNIST(root='./data/',
train=True,
transform=transforms.ToTensor(),
download=True)
test_data = datasets.MNIST(root='./data/',
train=False,
transform=transforms.ToTensor())
# 返回一个数据迭代器
# shuffle：是否打乱顺序
train_loader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_data,
batch_size=batch_size,
shuffle=False)
print("Loaded Data successfully!")
return train_loader, test_loader
获取数据的命令：
datasets.MNIST(root,train=True,transform=None,target_transform=None,download=False)
其中：
- root：数据集的根目录，如果已存在则直接加载，不存在则可设置download下载
- train：如果为True，则从training.pt创建数据集，否则从testing.pt创建数据集
- download: 如果为True，从互联网下载数据集，然后将其放在根目录中。 如果数据集已经存在则不会重复下载。
- transform：接受PIL图像并返回转换后版本的函数/转换。 例如transforms.ToTensor()（就是对图像数据进行处理，将类型转变为Tensor传入dataloader）
- target_transform：接受目标并对其进行转换的函数/转换。与上述相似。
数据分批加载：
torch.utils.data.DataLoader(dataset=train_data,batch_size=Config.batch_size,shuffle=True)
主要实现对数据的加载，批次的数据量设置，是否打乱设置。一般训练集打乱，测试集不打乱。
如果是对自己的数据集处理，则dataset=自己的数据集，不需要使用上述加载MNIST数据集的流程。
2、构建模型
这次主要使用BP神经网络构建，后续还会构建一些常见的CNN网络，如：LeNet、AlexNet、ResNet等进行构建。
本次构建主要包含输入层维度为28*28，输出层维度为10，隐藏层128。本次主要是对工具的使用进行介绍，小伙伴可以根据自己的需要构建网络，提高模型准确率等。
import torch
import torch.nn as nn
class BP(nn.Module):
def __init__(self):
super(BP, self).__init__()
# 构建隐藏层
self.fc1 = nn.Sequential(
nn.Linear(28*28, 128),
nn.ReLU()
)
# 构建输出层
self.fc2 = nn.Sequential(
nn.Linear(128, 10),
nn.Sigmoid()
)
def forward(self, x):
# 将照片铺平为1维向量
x = x.view(-1,784)
x = self.fc1(x)
x = self.fc2(x)
return x
data = torch.randn(1,28,28)
net = BP()
outputs = net(data)
print(outputs.shape)
构建的模型输出维度为(1,10)，10代表标签的类别数目
3、训练模型
选择合适的优化器，损失函数帮助我们的模型快速收敛，一般优化器选择Adam，SGD等效果较好，损失函数一般回归问题选择MSE，分类问题选择交叉熵损失。
选择损失为交叉熵损失
criterion = nn.CrossEntropyLoss()
选择优化器为Adam
optimizer = torch.optim.Adam()
对于一些参数的选择可以自行搜索
def train_step(self):
print("Training & Evaluating based on BP......")
file = './result/raw_train_mnist.txt'
fp = open(file,'w',encoding='utf-8')
fp.write('epoch\tbatch\tloss\taccuracy\n')
# 循环轮次
for epoch in range(Config.epoch):
# 显示当前轮
print("Epoch {:3}.".format(epoch + 1))
# 循环批次，每一批的数目当前设置128
for batch_idx,(data, label) in enumerate(self.train):
# 这里设置主要是我利用GPU训练，用cpu训练的可以忽略
data, label = Variable(data.cuda()), Variable(label.cuda())
# 优化器初始化
self.optimizer.zero_grad()
outputs = self.net(data)
# 计算损失
loss = self.criterion(outputs, label)
loss.backward()
# 进行优化计算
self.optimizer.step()
# 每100次打印一次结果
if batch_idx % Config.print_per_step == 0:
# 每100批次计算当前准确率
_, predicted = torch.max(outputs, 1)
correct = 0
for _ in predicted == label:
if _:
correct += 1
accuracy = correct / Config.batch_size
msg = "Batch: {:5}, Loss: {:6.2f}, Accuracy: {:8.2%}."
# 输出准确率
print(msg.format(batch_idx, loss, accuracy))
fp.write('{}\t{}\t{}\t{}\n'.format(epoch,batch_idx,loss,accuracy))
fp.close()
test_loss = 0.
test_correct = 0
for data, label in self.test:
data, label = Variable(data.cuda()), Variable(label.cuda())
outputs = self.net(data)
loss = self.criterion(outputs, label)
test_loss += loss * Config.batch_size
_, predicted = torch.max(outputs, 1)
correct = int(sum(predicted == label))
test_correct += correct
accuracy = test_correct / len(self.test.dataset)
loss = test_loss / len(self.test.dataset)
print("Test Loss: {:5.2f}, Accuracy: {:6.2%}".format(loss, accuracy))
torch.save(self.net.state_dict(),'./result/raw_train_mnist_model.pth')
4、整体代码以及模型训练
import torch
from torchvision import datasets, transforms
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
import numpy as np
device = torch.device('cuda:0')
class Config:
batch_size = 128
epoch = 10
alpha = 1e-3
print_per_step = 100 # 控制输出
class BP(nn.Module):
def __init__(self):
super(BP, self).__init__()
self.fc1 = nn.Sequential(
nn.Linear(28*28, 128),
nn.ReLU()
)
self.fc2 = nn.Sequential(
nn.Linear(128, 10),
nn.Sigmoid()
)
def forward(self, x):
x = x.view(-1,784)
x = self.fc1(x)
x = self.fc2(x)
return x
class TrainProcess:
def __init__(self):
self.train, self.test = self.load_data()
self.net = BP().to(device)
self.criterion = nn.CrossEntropyLoss() # 定义损失函数
self.optimizer = optim.Adam(self.net.parameters(), lr=Config.alpha)
@staticmethod
def load_data():
train_data = datasets.MNIST(root='./data/',
train=True,
transform=transforms.ToTensor(),
download=True)
test_data = datasets.MNIST(root='./data/',
train=False,
transform=transforms.ToTensor())
# 返回一个数据迭代器
# shuffle：是否打乱顺序
train_loader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=Config.batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_data,
batch_size=Config.batch_size,
shuffle=False)
return train_loader, test_loader
def train_step(self):
print("Training & Evaluating based on BP......")
file = './result/raw_train_mnist.txt'
fp = open(file,'w',encoding='utf-8')
fp.write('epoch\tbatch\tloss\taccuracy\n')
for epoch in range(Config.epoch):
print("Epoch {:3}.".format(epoch + 1))
for batch_idx,(data, label) in enumerate(self.train):
data, label = Variable(data.cuda()), Variable(label.cuda())
self.optimizer.zero_grad()
outputs = self.net(data)
loss = self.criterion(outputs, label)
loss.backward()
self.optimizer.step()
# 每100次打印一次结果
if batch_idx % Config.print_per_step == 0:
_, predicted = torch.max(outputs, 1)
correct = 0
for _ in predicted == label:
if _:
correct += 1
accuracy = correct / Config.batch_size
msg = "Batch: {:5}, Loss: {:6.2f}, Accuracy: {:8.2%}."
print(msg.format(batch_idx, loss, accuracy))
fp.write('{}\t{}\t{}\t{}\n'.format(epoch,batch_idx,loss,accuracy))
fp.close()
test_loss = 0.
test_correct = 0
for data, label in self.test:
data, label = Variable(data.cuda()), Variable(label.cuda())
outputs = self.net(data)
loss = self.criterion(outputs, label)
test_loss += loss * Config.batch_size
_, predicted = torch.max(outputs, 1)
correct = 0
for _ in predicted == label:
if _:
correct += 1
test_correct += correct
accuracy = test_correct / len(self.test.dataset)
loss = test_loss / len(self.test.dataset)
print("Test Loss: {:5.2f}, Accuracy: {:6.2%}".format(loss, accuracy))
torch.save(self.net.state_dict(),'./result/raw_train_mnist_model.pth')
if __name__ == "__main__":
p = TrainProcess()
p.train_step()
训练结果：
Training & Evaluating based on BP......
Epoch 1.
Batch: 0, Loss: 2.31, Accuracy: 10.16%.
Batch: 100, Loss: 1.68, Accuracy: 83.59%.
Batch: 200, Loss: 1.60, Accuracy: 89.84%.
Batch: 300, Loss: 1.60, Accuracy: 85.94%.
Batch: 400, Loss: 1.55, Accuracy: 91.41%.
Epoch 2.
Batch: 0, Loss: 1.54, Accuracy: 91.41%.
Batch: 100, Loss: 1.56, Accuracy: 89.84%.
Batch: 200, Loss: 1.53, Accuracy: 91.41%.
Batch: 300, Loss: 1.56, Accuracy: 91.41%.
Batch: 400, Loss: 1.51, Accuracy: 96.09%.
Epoch 3.
Batch: 0, Loss: 1.50, Accuracy: 97.66%.
Batch: 100, Loss: 1.54, Accuracy: 92.19%.
Batch: 200, Loss: 1.52, Accuracy: 93.75%.
Batch: 300, Loss: 1.51, Accuracy: 95.31%.
Batch: 400, Loss: 1.53, Accuracy: 93.75%.
Epoch 4.
Batch: 0, Loss: 1.51, Accuracy: 94.53%.
Batch: 100, Loss: 1.50, Accuracy: 94.53%.
Batch: 200, Loss: 1.52, Accuracy: 95.31%.
Batch: 300, Loss: 1.53, Accuracy: 93.75%.
Batch: 400, Loss: 1.50, Accuracy: 96.88%.
Epoch 5.
Batch: 0, Loss: 1.49, Accuracy: 96.88%.
Batch: 100, Loss: 1.50, Accuracy: 96.09%.
Batch: 200, Loss: 1.50, Accuracy: 97.66%.
Batch: 300, Loss: 1.50, Accuracy: 93.75%.
Batch: 400, Loss: 1.50, Accuracy: 95.31%.
Epoch 6.
Batch: 0, Loss: 1.51, Accuracy: 96.88%.
Batch: 100, Loss: 1.51, Accuracy: 94.53%.
Batch: 200, Loss: 1.54, Accuracy: 92.97%.
Batch: 300, Loss: 1.48, Accuracy: 97.66%.
Batch: 400, Loss: 1.51, Accuracy: 96.09%.
Epoch 7.
Batch: 0, Loss: 1.50, Accuracy: 96.88%.
Batch: 100, Loss: 1.51, Accuracy: 95.31%.
Batch: 200, Loss: 1.49, Accuracy: 96.88%.
Batch: 300, Loss: 1.50, Accuracy: 94.53%.
Batch: 400, Loss: 1.49, Accuracy: 94.53%.
Epoch 8.
Batch: 0, Loss: 1.49, Accuracy: 96.88%.
Batch: 100, Loss: 1.49, Accuracy: 97.66%.
Batch: 200, Loss: 1.49, Accuracy: 96.88%.
Batch: 300, Loss: 1.51, Accuracy: 96.09%.
Batch: 400, Loss: 1.51, Accuracy: 96.88%.
Epoch 9.
Batch: 0, Loss: 1.49, Accuracy: 96.88%.
Batch: 100, Loss: 1.50, Accuracy: 95.31%.
Batch: 200, Loss: 1.49, Accuracy: 96.09%.
Batch: 300, Loss: 1.49, Accuracy: 96.09%.
Batch: 400, Loss: 1.49, Accuracy: 98.44%.
Epoch 10.
Batch: 0, Loss: 1.48, Accuracy: 97.66%.
Batch: 100, Loss: 1.48, Accuracy: 98.44%.
Batch: 200, Loss: 1.50, Accuracy: 95.31%.
Batch: 300, Loss: 1.49, Accuracy: 97.66%.
Batch: 400, Loss: 1.49, Accuracy: 97.66%.
Test Loss: 1.51, Accuracy: 97.02%
这里训练了10的epoch就可以达到97%，而且是非常简单的神经网络。希望可以帮助大家可以快速上手pytorch。
Original: https://blog.csdn.net/qq_37320084/article/details/121377399
Author: AI小蜗牛
Title: 基于pytorch的BP神经网络模型构建
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/690932/
转载文章受原作者版权保护。转载请注明原作者出处！