torch学习第一天

基于mnist数据的神经网络构建

---

---

前言

利用神经网络完成对手写数字进行识别的实例，并且简单的构建一个分类器，相应的步骤：
1：利用pytorch内置函数mnist下载数据集
2：利用torchvision 对数据进行预处理，调用torch.utils建立一个数据 迭代器
3：可是化数据
4：利用nn工具构建神经网络
5：实例化模型，并定义算是函数及其优化器
6：训练模型
7：可视化结果

---

提示：以下是本篇文章正文内容

一、网络构建

1.引入库

代码如下（示例）：

# 导入必要的包
import numpy as np
import torch
# 导入数据集
from torchvision.datasets import mnist
# 导入预处理模块
import torchvision.transforms as transforms
"""
transforms中的常见操作:
torchvision.transforms.CenterCrop(size):进行中心切割，得到给定的size
torchvision.transforms.RandomCrop(size, padding=0):切割中心点的位置随机选取
torchvision.transforms.RandomHorizontalFlip:随机水平翻转;可以给定的概率为0.5。即：一半的概率翻转，一半的概率不翻转
torchvision.transforms.RandomSizedCrop(size, interpolation=2):随机剪切，然后再resize成给定的size大小
torchvision.transforms.Pad(padding, fill=0)：所有边用给定的pad value填充。 padding：要填充多少像素 fill：用什么值填充
transforms.Normalize:对数据进行归一化，前一个0.5是平均值，第二个是方差，如果是多通道的就需要设置多个数值
"""
from torch.utils.data import DataLoader
# 导入nn模块
import torch.nn.functional as F
import torch.optim as optim
from torch import nn
from tqdm import tqdm

2.定义超参数

代码如下：

# 定义超参数
trian_batch_size=32 
test_batch_size=64
num_epoches = 20
learning_rate=0.01 # 学习率
momentum =0.5 # 动量设置

3.下载数据集并对数据集进行预处理

# transforms.Compose 该函数的作用是用来整合数据处理的操作的，也就是把所有的预处理操作全部放在一个transform里面
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5],[0.5])])

# 下载数据集
train_dataset = mnist.MNIST(r"E:\jupter-file\",train=True,transform=transform,download=True)
test_dataset = mnist.MNIST(r"E:\jupter-file\",train=False,transform=transform,download=True)
# dataloader本质是一个可迭代对象，使用iter()访问，不能使用next()访问
train_loader = DataLoader(train_dataset,batch_size=trian_batch_size,shuffle=True)
test_loader = DataLoader(test_dataset,batch_size=test_batch_size,shuffle=False)

4.数据可视化

# ——————————————可视化——————————————————
import matplotlib.pyplot as plt
%matplotlib inline
examples = enumerate(test_loader)
batch_idx ,(example_data,example_label) =next(examples)
fig = plt.figure()
for i in range(6):
    plt.subplot(2,3,i+1)
    plt.tight_layout()
    plt.imshow(example_data[i][0],cmap="gray",interpolation='none')
    plt.title("ground truth :{}".format(example_label[i]))
    plt.axis("off")
    plt.xticks([])
    plt.yticks([])
# plt.show()

5.构建模型

class Net(nn.Module):
    """
    使用sequential构建网络，Sequential（）函数的功能是将网络的层组合在一起
    """
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        """
        :param in_dim:输入的通道数
        :param n_hidden_1: 第一层神经元数量
        :param n_hidden_2: 第二层神经元的数量
        :param out_dim: 最后的输出通道数
        """
        super(Net,self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim,n_hidden_1),
                                    nn.BatchNorm1d(n_hidden_1))
        self.layer2 = nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),
                                    nn.BatchNorm1d(n_hidden_2))
        self.layer3 = nn.Sequential(nn.Linear(n_hidden_2,out_dim))
    def forward(self,x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return  x

6.实例化模型

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# device = "cpu"
# 实例化网络
model = Net(28*28,300,100,10)
model.to(device)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=learning_rate,momentum=momentum)

7.训练网络

# 训练模型
losses = []
acces = []
eval_losses = []
eval_acces= []
for epoch in range(num_epoches):
    train_loss = 0
    train_acc = 0
    # 随着轮数的变换，改变学习率
    if epoch%5==0:
        optimizer.param_groups[0]['lr']*= 0.1 
    for img,label in tqdm(train_loader):
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0),-1)
        # 前向传播
        out = model(img)
        loss = criterion(out,label)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 记录误差
        train_loss +=loss.item()
        # 计算分类的准确率
        _,pred =out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct/img.shape[0]
        train_acc +=acc
    losses.append(train_loss / len(train_loader))
    acces.append(train_acc / len(train_loader))

    # 在测试集上进行测试
    eval_loss = 0
    eval_acc = 0
    # 将模型改为预测模式
    model.eval()
    for img,label in tqdm(test_loader):
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0),-1)
        out = model(img)
        loss = criterion(out,label)
        eval_loss +=loss.item()
        _,pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct /img.shape[0]
        eval_acc +=acc
    eval_losses.append(eval_loss / len(test_loader))
    eval_acces.append(eval_acc / len(test_loader))
    print("epoch:{},trian Loss:{:.4f},train acc:{:.4f},Test loss:{:.4f},"
          "test ACC:{:.4f}".format(epoch,train_loss/len(train_loader),
                                   train_acc/len(train_loader),eval_loss/len(test_loader),
                                   eval_acc/len(test_loader)))
                                   

epoch:8,trian Loss:0.0991,train acc:0.9728,Test loss:0.1105,test ACC:0.9666
100%|██████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:39<00:00, 46.89it/s]
100%|████████████████████████████████████████████████████████████████████████████████| 157/157 [00:03<00:00, 43.01it/s]
epoch:9,trian Loss:0.0977,train acc:0.9732,Test loss:0.1105,test ACC:0.9667

8.可视化训练和测试的损失值和精确度

plt.title("loss_acc")
plt.plot(np.arange(len(losses)),losses)
plt.plot(np.arange(len(acces)),acces)
plt.plot(np.arange(len(eval_losses)),eval_losses)
plt.plot(np.arange(len(eval_acces)),eval_acces)
plt.legend(["Train Loss","Train acc","Eval Loss","Eval acc"])