深度学习-torch-手写数字识别-Basic_CNN

网络模型：
模型构建：

代码如下：

import torch
# torch 框架下的图像处理包，可以做图像预处理
from torchvision import transforms
##torch 框架下的图像处理包，可以用来生成图片和视频数据集
from torchvision import datasets
# 这是一个训练加载器，用来把训练分成多个小组，此函数每次抛出一个小组数组，直至把所有数据进行抛出
from torch.utils.data import DataLoader
# 非线性函数relu会用到的函数库
import torch.nn.functional as F
# 优化函数库
import torch.optim as optim

# -------------prepare dataset-----------
# batch_size表示每个批次大小是60
# epoch:表示一轮数据全部跑完的过程；batch_size:每次跑的数据量；iteration:总数据/batch_size
batch_size = 60
# 为了做一个高效的图像处理，ToTensor()把H×W×C的图像转化为一个Tensor：C×H×W，并将[0，255]的数据进行归一化
# 把图片数据映射到均值为0.1307，标准差为0.3081的（0,1）分布里面，这个过程成为标准化，mean，std是对所有mnist数据集计算过的数据；
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# datasets不能被实例化
# DataLoader帮助加载数据，可以被实例化
# 参数root：数据集存放位置；我的数据存放位置为：D:\PycharmProjects\dataset\mnist\MNIST\raw，../表示和myProjection在同一目录下
# 参数train：训练集设置成True，测试集设置成False；参数download：数据集没有下载设置成True,第一次用就设置成True,如果已经下载，不会再下载；
# datasets.CIFAR10也是一个分类的数据集，training set:50000 examples,test set:10000 examples,classes:10;
train_dataset = datasets.MNIST(root="../dataset/mnist/", train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root="../dataset/mnist/", train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=True, batch_size=batch_size)
# ---------------------------------------

# ------------struct model---------------
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv_layer1 = torch.nn.Conv2d(1, 10, kernel_size=5, bias=False)
        self.max_pooling = torch.nn.MaxPool2d(2)
        self.conv_layer2 = torch.nn.Conv2d(10, 20, kernel_size=5, bias=False)
        self.fc = torch.nn.Linear(320, 10)

    # ---------------------------------------
    def forward(self, x):
        # 输入的数据shape是（batch_size,1,28,28）,1表示图像都是单通道的灰度图，28×28表示H×W
        # 输出的数据shape是（batch_size,10），10表示手写数字识别是10分类问题
        batch_size = x.size(0)
        # 卷积，池化，卷积，池化，
        x = F.relu(self.conv_layer1(x))  # 64×1×28×28  ->  60×10×24×24
        x = F.relu(self.conv_layer2(self.max_pooling(x)))  # 60×10×24×24  ->  60×10×12×12  ->  60×20×8×8
        x = self.max_pooling(x)  # 60×20×8×8  ->  60×20×4×4
        x = x.view(batch_size, -1)  # 60×20×4×4  ->60×320
        x = self.fc(x)  # 60×320  -> 60×10
        return x
model = Net()  # 实例化模型
# ---------------------------------------

# ------------MSE+optimizer---------------
criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失，调用的时候criterion(预测值，真实值)
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 优化器
# ---------------------------------------

# ------------train+test---------------
def train(epoch):
    running_loss = 0.0  # 每一个batch_size计算一次平均损失
    for batch_idx, data in enumerate(train_loader, 0):  # 随机取60张图片
        inputs, target = data  # 输入图片，真实结果
        optimizer.zero_grad()  # 梯度清零
        outputs = model(inputs)  # 模型调用
        # 通过输出过程变量，发现labels是1*64，每个batch输入64张图片，每个数字图片得到的十个分类，却之对应一个labels，这样是无法计算交叉熵
        # 查阅资料发现输入的真实label为[2]，pytorch会自动转化为[0,0,1,0,0,0,0,0,0,0]的one_hot进行计算交叉熵
        loss = criterion(outputs, target)  # 计算损失
        loss.backward()  # 计算梯度
        optimizer.step()  # 梯度更新
        """
        #用于查看过程变量的shape
        print('outputs_shape', outputs.shape)#60*10
        print('target_shape', target.shape)#1*60
        print('outputs', outputs)
        print('target', target)
        """
        running_loss += loss  # 每一个batch_size的损失和
        if batch_idx % 300 == 299:
            print('[%d,%5d]  loss:%.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


def test():
    correct = 0  # 识别正确的图片数量
    total = 0  # 总识别图片的数量
    with torch.no_grad():  # 不计算梯度
        for data in test_loader:
            images, labels = data  # 输入图片，正确标签
            outputs = model(images)  # 调用模型
            # _表示具体的最大值value，没有用，不必关注；predicted表示获取每一行的最大值的index，即其对应的数字（从0开始）
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)  # 每次图片总数都是加一个batch_size
            """
            #用来观察过程变量的输出，加深理解
            print('images',images)#60*1*28*28
            print('outputs',outputs)#60*10
            print('labels', labels)#1*60
            print('_',_)#1*60
            print('predicted',predicted)#1*60
            """
            # 正确的数量是predicted和labels匹配数量，匹配返回值为True,等价1
            correct += (predicted == labels).sum().item()  
    print('accurancy:%.3f %%' % (correct / total * 100))


if __name__ == '__main__':
    for epoch in range(10):  # 训练10个epoch，观察测试数据集准确度的变化
        train(epoch)
        test()
# ---------------------------------------

运行结果：

epoch-accurancy 图：