06-使用pytorch实现手写数字识别
目录
1.思路和流程分析
2.准备训练集和测试集
2.1 torchvision.transforms的图形数据处理方法
2.1.1 torchvison.transforms.ToTensor
2.1.2 torchvision.transforms.Normalize(mean,std)
2.1.3 torchvision.transforms.Compose(transforms)
2.2 准备MNIST数据集的Dataset和DataLoader
3.构建模型
3.1 激活函数的使用
3.2 模型中数据的形状（【添加形状变化图形】）
3.3 模型的损失函数
4.模型的训练
5.模型的保存和加载
5.1 模型的保存
5.2 模型的加载
6.模型的评估
7.总的代码
1.思路和流程分析
2.准备训练集和测试集
2.1 torchvision.transforms的图形数据处理方法
2.1.1 torchvison.transforms.ToTensor
from torchvision.datasets import MNIST
mnist=MNIST(root=r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\datas',train=True,download=True,transform=None)#len(mnist)==60000
print(mnist[0])#(<PIL.Image.Image image mode=L size=28x28 at 0x1D5F6298EE0>, 5)
img=mnist[0][0]
img.show()#打开图片
from torchvision import transforms
import numpy as np
data=np.random.randint(0,255,size=12)
img=data.reshape(2,2,3)
print(img.shape)
img_tensor=transforms.ToTensor()(img)#转换成tensor
print(img_tensor)
print(img_tensor.size())输出如下：
(2, 2, 3)
tensor([[[235, 30],
[236, 92]],
[[ 1, 113],
[ 53, 5]],
[[ 21, 190],
[ 46, 11]]], dtype=torch.int32)
torch.Size([3, 2, 2])
2.1.2 torchvision.transforms.Normalize(mean,std)
from torchvision import transforms
import numpy as np
import torchvision
data=np.random.randint(0,255,size=12)
img=data.reshape(2,2,3)
img=transforms.ToTensor()(img)#转换成tensor
print(img)
print('*'*100)
norm_img=transforms.Normalize((10,10,10),(1,1,1))(img)#进行规范化处理
print(norm_img)2.1.3 torchvision.transforms.Compose(transforms)
transforms.Compose([
torchvision.transforms.ToTensor(),#先转换为Tensor
torchvision.transforms.Normalize(mean,std)#再进行正则化
])2.2 准备MNIST数据集的Dataset和DataLoader
准备训练集：
from torchvision.datasets import MNIST
from torchvision.transforms import Compose,ToTensor,Normalize
from torch.utils.data import DataLoader
BATCH_SIZE=128
#1.准备数据
def get_dataloader(train=True):
transform_fn = Compose([
ToTensor(),
Normalize(mean=(0.1307,), std=(0.3081,)) # mean std的形状和通道数相同
])
dataset = MNIST(root=r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\datas', train=True, transform=transform_fn)
data_loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
return data_loader
3.构建模型
3.1 激活函数的使用
import torch
import torch.nn.functional as F
b=torch.Tensor([-2,-1,0,1,2])
print(F.relu(b)) #tensor([0., 0., 0., 1., 2.])3.2 模型中数据的形状（【添加形状变化图形】）
import torch.nn as nn
import torch.nn.functional as F
#2.构建模型
class MnistNodel(nn.Module):
def __init__(self):
super(MnistNodel,self).__init__()
self.fc1=nn.Linear(1*28*28,28)#第一个全连接
self.fc2=nn.Linear(28,10)#第二个全连接 最终有10个类别
def forward(self,input):
"""
:param input:[batch_size,1,28,28]
:return:输出层
"""
#1.修改形状
x=input.view([input.size(0),1*28*28])#或者input.view([-1,1*28*28])
#2，进行全连接的操作
x=self.fc1(x)
#3.进行激活函数的处理
x=F.relu(x)#形状无变化
#4.输出层
out=self.fc2(x)
return out3.3 模型的损失函数
#方法一
criterion=nn.CrossEntropyLoss()#交叉熵损失
loss=criterion(input,target)
#方法二
output=F.log_softmax(x,dim=-1)#1.对输出值计算softmax和取对数
loss=F.nll_loss(output,target)#2.使用torch中带权损失nll_loss
4.模型的训练
from torch.optim import Adam
model=MnistNodel()#实例化模型
optimizer=Adam(model.parameters(),lr=0.001)
def train(epoch):
'''实现训练的过程'''
data_loader=get_dataloader()
for idx,(input,target) in enumerate(data_loader):
optimizer.zero_grad()
output=model(input)#调用模型，得到预测值
loss=F.nll_loss(output,target)#得到损失
loss.backward()#反向传播
optimizer.step()#梯度的更新
if idx%100==0:
print(epoch,idx,loss.item(),sep='\t')5.模型的保存和加载
5.1 模型的保存
torch.save(model.state_dict(),'path')#保存模型参数
torch.save(optimizer.state_dict(),'path')#保存优化器参数5.2 模型的加载
model.load_state_dict(torch.load('path'))
optimizer.load_state_dict(torch.load('path'))6.模型的评估
import numpy as np
def test():
loss_list=[]
acc_list=[]
test_dataloader=get_dataloader(train=False)
for idx,(input,target) in enumerate(test_dataloader):
with torch.no_grad():
output=model(input)
cur_loss=F.nll_loss(output,target)
loss_list.append(cur_loss)
#计算准确率
#output [batch_size,10] target:[batch_size]
pred=output.max(dim=-1)[-1]
cur_acc=pred.eq(target).float().mean()
acc_list.append(cur_acc)
print('平均准确率：',np.mean(acc_list),'\t平均损失：',np.mean(loss_list))
#结果如下：
# 平均准确率： 0.9503709 平均损失： 0.173100497.总的代码
import torch,os
import numpy as np
from torchvision.datasets import MNIST
from torchvision.transforms import Compose,ToTensor,Normalize
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
BATCH_SIZE=128
#1.准备数据
def get_dataloader(train=True):
transform_fn = Compose([
ToTensor(),
Normalize(mean=(0.1307,), std=(0.3081,)) # mean std的形状和通道数相同
])
dataset = MNIST(root=r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\datas', train=True, transform=transform_fn)
data_loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
return data_loader
#2.构建模型
class MnistNodel(nn.Module):
def __init__(self):
super(MnistNodel,self).__init__()
self.fc1=nn.Linear(1*28*28,28)#第一个全连接
self.fc2=nn.Linear(28,10)#第二个全连接 最终有10个类别
def forward(self,input):
"""
:param input:[batch_size,1,28,28]
:return:输出层
"""
#1.修改形状
x=input.view([input.size(0),1*28*28])#或者input.view([-1,1*28*28])
#2，进行全连接的操作
x=self.fc1(x)
#3.进行激活函数的处理
x=F.relu(x)#形状无变化
#4.输出层
out=self.fc2(x)
return F.log_softmax(out)
model=MnistNodel()#实例化模型
if os.path.exists(r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\模型的保存\mnist_model.pkl'):
model.load_state_dict(torch.load(r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\模型的保存\mnist_model.pkl'))
optimizer=Adam(model.parameters(),lr=0.001)
if os.path.exists(r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\模型的保存\mnist_optimizer.pkl'):
optimizer.load_state_dict(torch.load(r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\模型的保存\mnist_optimizer.pkl'))
def train(epoch):
'''实现训练的过程'''
data_loader=get_dataloader()
for idx,(input,target) in enumerate(data_loader):
optimizer.zero_grad()
output=model(input)#调用模型，得到预测值
loss=F.nll_loss(output,target)#得到损失
loss.backward()#反向传播
optimizer.step()#梯度的更新
if idx%100==0:
print(epoch,idx,loss.item(),sep='\t')
#模型的保存
if idx%100==0:#每隔100个保存一下
torch.save(model.state_dict(),r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\模型的保存\mnist_model.pkl')
torch.save(optimizer.state_dict(),r'D:\各种编译器的代码\pythonProject12\机器学习\NLP自然语言处理\模型的保存\mnist_optimizer.pkl')
def test():
loss_list=[]
acc_list=[]
test_dataloader=get_dataloader(train=False)
for idx,(input,target) in enumerate(test_dataloader):
with torch.no_grad():
output=model(input)
cur_loss=F.nll_loss(output,target)
loss_list.append(cur_loss)
#计算准确率
#output [batch_size,10] target:[batch_size]
pred=output.max(dim=-1)[-1]
cur_acc=pred.eq(target).float().mean()
acc_list.append(cur_acc)
print('平均准确率：',np.mean(acc_list),'\t平均损失：',np.mean(loss_list))
if __name__ == '__main__':
# for i in range(3):#训练三轮
# train(i)
test()