CNN 卷积神经网络 手写数字 图像识别 （深度学习）

---

✌ 卷积神经网络手写数字图像识别

1、✌ 导入相关库

# pytorch框架
import torch
from torch import nn,optim
from torchvision import datasets,transforms
from torch.utils.data import DataLoader

# 加载图片
from PIL import Image
from torchvision import models

2、✌ 导入手写数据集

# 从指定路径加载数据集，不下载，并将其转化为Tensor格式
train_dataset = datasets.MNIST(root='./',
                train=True,
                transform=transforms.ToTensor(),
                download=False)

test_dataset = datasets.MNIST(root='./',
               train=False,
               transform=transforms.ToTensor(),
               download=False)

3、✌ 定义数据包装器

# 每批的数据为64个，用于数据加载，shuffle为打乱数据
batch_size=64
train_loader=DataLoader(dataset=train_dataset,
                       batch_size=batch_size,
                       shuffle=True)
test_loader=DataLoader(dataset=test_dataset,
                      batch_size=batch_size,
                      shuffle=True)

4、✌ 查看数据维度

# 该维度表示64张图片，每张的channel为1，宽高为28，28
for i, data in enumerate(train_loader):
    inputs, labels = data
    print(inputs.shape)
    print(labels.shape)
    break

5、✌ 定义卷积网络层

# nn.Module
class CNN(nn.Module):
	# 初始化相关网络层
    def __init__(self):
    	# 初始化父类
        super(CNN,self).__init__()
        # 定义第一个卷积层
        self.conv1=nn.Sequential(nn.Conv2d(1,64,5,1,2),nn.ReLU(),nn.MaxPool2d(2,2))
        # 定义第二个卷积层
        self.conv2=nn.Sequential(nn.Conv2d(64,128,5,1,2),nn.ReLU(),nn.MaxPool2d(2,2))
        # 定义全连接层
        self.fc1=nn.Sequential(nn.Linear(128*7*7,1000),nn.Dropout(p=0.2),nn.ReLU())
        self.fc2=nn.Sequential(nn.Linear(1000,10),nn.Softmax(dim=1))
    # 定义传播函数
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.reshape(x.shape[0], -1)
        x = self.fc1(x)
        x = self.fc2(x)
        return x

6、✌ 定义模型与损失函数、优化器

# 学习率
LR=0.0003
# 定义模型
model=CNN()
# 定义损失函数：交叉熵
loss_fn=nn.CrossEntropyLoss()
# 定义优化器
optimizer=optim.Adam(model.parameters(),LR)

7、✌ 训练、测试函数

def train():
    model.train()
    for i,data in enumerate(train_loader):
        x,y=data
        # 预测结果
        y_pred=model(x)
        # 计算损失
        loss=loss_fn(y_pred,y)
        # 梯度清0
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 修改权值
        optimizer.step()
def test():
    model.eval()
    correct=0
    for i,data in enumerate(train_loader):
        x,y=data
        y_pred=model(x)
        _,pred=torch.max(y_pred,1)
        correct+=(pred==y).sum()
    print('准确率：',correct.item()/len(train_dataset))
    correct = 0
    for i, data in enumerate(test_loader):
        x,y=data
        y_pred=model(x)
        _,pred=torch.max(y_pred,1)
        correct+=(pred==y).sum()
    print('准确率：',correct.item()/len(test_dataset))

8、✌ 网络迭代训练

# 训练10次模型，不断修改权重
for epoch in range(1,11):
    print('epoch:',epoch)
    train()
    test()

9、✌ 保存模型

# 将模型的参数保存到D盘
torch.save(model.state_dict(),r'D:\res.pth')

10、✌ 加载模型

# 重新定义模型，加载保存的参数
model=CNN()
model.load_state_dict(torch.load(r'D:\res.pth'))
loss_fn=nn.CrossEntropyLoss()
optimizer=optim.Adam(model.parameters(),LR)

11、✌ 模型测试

# 将图片转化为Tensor
transform = transforms.Compose([
    transforms.ToTensor() 
])
# 打开图片
img=Image.open(r'C:\Users\HUAWEI\Desktop\7.jpg')
# 改变图片大小
img=img.resize((28,28))
# 图片灰度化
img=img.convert('L')
# 将图片增加一个维度，卷积层需要4维
img=transform(img).unsqueeze(0)
out=model(img)
_,pred=torch.max(out,1)
print('该数字为:',pred.item())