全部源码请点赞关注收藏后评论区留言即可~~~
下面使用torchvision.datasets.MNIST构建手写数字数据集。
1：数据预处理
PyTorch提供了torchvision.transforms用于处理数据及数据增强，它可以将数据从[0,255]映射到[0,1]
2：读取训练数据
准备好处理数据的流程后，就可以读取用于训练的数据了，torch.util.data.DataLoader提供了迭代数据，随机抽取数据，批量化数据等等功能 读取效果如下
预处理过后的数据如下
3：构建神经网络模型
下面构建用于识别手写数字的神经网络模型
class MLP(nn.Module): def __init__(self): super(MLP,self).__init__() self.inputlayer=nn.Sequential(nn.Linear(28*28,256),nn.ReLU(),nn.Dropout(0.2)) self.hiddenlayer=nn.Sequential(nn.Linear(256,256),nn.ReLU(),nn.Dropout(0.2)) self.outputlayer=nn.Sequential(nn.Linear(256,10)) def forward(self,x): x=x.view(x.size(0),-1) x=self.inputlayer(x) x=self.hiddenlayer(x) x=self.outputlayer(x) return x
可以直接通过打印nn.Module的对象看到其网络结构
4：模型评估
在准备好数据和模型后，就可以训练模型了，下面分别定义了数据处理和加载流程，模型，优化器，损失函数以及用准确率评估模型能力。
得到的结果如下
训练一次 可以看出比较混乱 没有说明规律可言
训练五次的损失函数如下 可见随着训练次数的增加是逐渐收敛的，规律也非常明显
准确率图像如下
最后 部分源码如下
import torch import torchvision import torch.nn as nn from torch import optim from tqdm import tqdm import torch.utils.data.dataset mnist=torchvision.datasets.MNIST(root='~',train=True,download=True) for i,j in enumerate(np.random.randint(0,len(mnist),(10,))): data,label=mnist[j] plt.subplot(2,5,i+1) plt.show() trans=transforms.Compose( [ transforms.ToTensor(), transforms.Normalize((0.1307,),(0.3081,)) ] ) normalized=trans(mnist[0][0]) from torchvision import transforms mnist=torchvision.datasets.MNIST(root='~',train=True,download=True,transform=trans) def imshow(img): img=img*0.3081+0.1307 npimg=img.numpy() plt.imshow(np.transpose(npimg,(1,2,0))) dataloader=DataLoader(mnist,batch_size=4,shuffle=True,num_workers=0) images,labels=next(iter(dataloader)) imshow(torchvision.utils.make_grid(images)) class MLP(nn.Module): def __init__(self): super(MLP,self).__init__() self.inputlayer=nn.Sequential(nn.Linear(28*28,256),nn.ReLU(),nn.Dropout(0.2)) self.hiddenlayer=nn.Sequential(nn.Linear(256,256),nn.ReLU(),nn.Dropout(0.2)) self.outputlayer=nn.Sequential(nn.Linear(256,10)) def forward(self,x): x=x.view(x.size(0),-1) x=self.inputlayer(x) x=self.hiddenlayer(x) x=self.outputlayer(x) return x print(MLP()) trans=transforms.Compose( [ transforms.ToTensor(), transforms.Normalize((0.1307,),(0.3081,)) ] ) al=torchvision.datasets.MNIST(root='~',train=False,download=True,transform=trans) trainloader=DataLoader(mnist_train,batch_size=16,shuffle=True,num_workers=0) valloader=DataLoader(mnist_val,batch_size=16,shuffle=True,num_workers=0) #模型 model=MLP() #优化器 optimizer=oD(model.parameters(),lr=0.01,momentum=0.9) #损失函数 celoss=nn.ssEntropyLoss() best_acc=0 #计算准确率 def accuracy(pred,target): pred_label=torch.amax(pred,1) correct=sum(pred_label==target).to(torch.float) return correct,len(pred) acc={'train':[],"val} loss_all={'train':[],"val":[]} for epoch in tqdm(range(5)): model.eval() numer_val,denumer_val,loss_tr=0.,0.,0. with torch.no_grad(): for data,target in valloader: output=model(data) loss=celoss(output,target) loss_tr+=loss.data num,denum=accuracy(output,target) numer_val+=num denumer_val+=denum #设置为训练模式 model.train() numer_tr,denumer_tr,loss_val=0.,0.,0. for data,target in trainloader: optizer.zero_grad() output=model(data) loss=celoss(output,target) loss_val+=loss.data loss.backward() optimer.step() num,denum=accuracy(output,target) numer_tr+=num denumer_tr+=denum loss_all['train'].append(loss_tr/len(trainloader)) loss_all['val'].aend(lss_val/len(valloader)) acc['train'].pend(numer_tr/denumer_tr) acc['val'].append(numer_val/denumer_val) """ plt.plot(loss_all['train']) plt.plot(loss_all['val']) """ plt.plot(acc['train']) plt.plot(acc['val']) plt.show()
创作不易 觉得有帮助请点赞关注收藏~~~
