pytorch之卷积mnsit手写数字（笔记六）

感受野的概念：

卷积核概念：（有不同的卷积核和不同的步长）

卷积的池化：（最大值池化、平均值池化、随机值池化），经常使用的就是max-pooling最大池化

SAME PADDING：表示给卷积外部补零

VALID PADDING：表示不超出平面外部，卷积不足的时候就停止

列子：

LENET5介绍：

具体的演示请参考：（2d和3d的演示卷积过程）

可视化：
http://scs.ryerson.ca/~aharley/vis/conv/
http://scs.ryerson.ca/~aharley/vis/conv/fat.html

卷积mnsit手写数字代码：

#使用卷积进行mnsit手写数字识别
import numpy as np
import torch
from torch import nn,optim
from torch.autograd import Variable
from torchvision import datasets,transforms
from torch.utils.data import DataLoader
#训练集
train_dataset=datasets.MNIST(root='./', #存放到项目目录下
                             train=True,  #是训练数据
                             transform=transforms.ToTensor(),  #转换成基本类型tensor数据
                             download=True) #需要下载
#测试集
test_dataset=datasets.MNIST(root='./',
                             train=False,
                             transform=transforms.ToTensor(),
                             download=True)

#每次训练图片的数量
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
                       )
for i,data in enumerate(train_loader):
    inputs,labels=data
    print(inputs.shape)
    print(labels.shape)
    break

#定义网络结构(使用卷积定义)
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()#调用父类方法
        #Dropout一部分神经元工作一部分不工作
        self.conv1=nn.Sequential(nn.Conv2d(1,32,5,1,2),nn.ReLU(),nn.MaxPool2d(2,2))#nn.ReLU()表示非线性激活函数；
        # nn.MaxPool2d(2,2)表示池化，2是2*2卷积，2表示步长是2
        #Conv2d(1, 32, 5, 1, 2),1表示输入的是黑白图片，通道是1，彩色就是3；32表示卷积完之后输出32个特征图；5表示卷积核大小，是5*5；
        #1表示卷积核的步长是1；2表示给图像的外面填写几圈0。
        self.conv2 = nn.Sequential(nn.Conv2d(32,64,5,1,2), nn.ReLU(), nn.MaxPool2d(2,2))
        #全连接层
        self.fc1 = nn.Sequential(nn.Linear(64*7*7,1000), nn.Dropout(p=0.5),nn.ReLU())#64*7*7表示64个特征图，7*7的卷积
        self.fc2=nn.Sequential(nn.Linear(1000,10),nn.Softmax(dim=1))
    def forward(self,x):
        #[64,1,28,28]卷积必须传入4维的数据
        x=self.conv1(x)
        x=self.conv2(x)
        # 全连接要求数据是2维的
        #（64,64,7,7），批次是64,64个特征图，每个特征图大小是7*7；-1表示自动匹配
        x=x.view(x.size()[0],-1)
        x=self.fc1(x)
        x=self.fc2(x)
        return x
#学习率
LR=0.001
#定义模型
model=Net()
#定义代价函数(均方差)
mse_loss=nn.MSELoss()
#定义优化器,weight_decay设置L2正则化
optimizer=optim.Adam(model.parameters(),LR)

def train():
    # 表示训练状态， #Dropout一部分神经元工作一部分不工作
    model.train()
    for i,data in enumerate(train_loader):
        #获得一个皮次数据和标签
        inputs,labels=data
        #获得模型预测结果（64,10）
        out=model(inputs)
        #to onehot,把数据编码变成独热编码
        #（64）编程（64，-1）
        labels=labels.reshape(-1,1)
        #tensor.scatter(dim,index,src)
        #dim对那个维度进行独热编码
        #index：要将src中对应的值放到tensor的哪个位置
        #src：插入index的数值
        one_hot=torch.zeros(inputs.shape[0],10).scatter(1,labels,1)
        #计算loss,mse_loss的俩个数据的shape要一致
        loss=mse_loss(out,one_hot)
        #梯度清零
        optimizer.zero_grad()
        #计算梯度
        loss.backward()
        #修改权值
        optimizer.step()

#测试
def test():
    # 表示模型测试状态，#Dropout所有神经元都要工作
    model.eval()
    correct=0
    for i,data in enumerate(test_loader):
        #获取一个批次的数据和标签
        inputs,labels=data
        #获得模型的预测结果（64,10）
        out=model(inputs)
        #获取最大值，以及最大值所在的位置
        _,predicted=torch.max(out,1)
        # 预测正确的数量
        correct += (predicted == labels).sum()
    print("Test acc:{0}".format(correct.item()/len(test_dataset)))

    correct = 0
    for i, data in enumerate(train_loader):
        # 获取一个批次的数据和标签
        inputs, labels = data
        # 获得模型的预测结果（64,10）
        out = model(inputs)
        # 获取最大值，以及最大值所在的位置
        _, predicted = torch.max(out, 1)
        # 预测正确的数量
        correct += (predicted == labels).sum()
    print("Train acc:{0}".format(correct.item() / len(train_dataset)))

for epoch in range(10):
    print("epoch:",epoch)
    train()
    test()

测试结果：

F:\开发工具\pythonProject\tools\venv\Scripts\python.exe F:/开发工具/pythonProject/tools/pytools/pytools04.py
torch.Size([64, 1, 28, 28])
torch.Size([64])
epoch: 0
Test acc:0.9853
Train acc:0.9858
epoch: 1
Test acc:0.9896
Train acc:0.9900666666666667
epoch: 2
Test acc:0.9899
Train acc:0.9923166666666666
epoch: 3
Test acc:0.9919
Train acc:0.9944166666666666
epoch: 4
Test acc:0.9927
Train acc:0.9957666666666667
epoch: 5
Test acc:0.9921
Train acc:0.9962
epoch: 6
Test acc:0.9905
Train acc:0.99495
epoch: 7
Test acc:0.9921
Train acc:0.99665
epoch: 8
Test acc:0.9922
Train acc:0.9953166666666666
epoch: 9
Test acc:0.9914
Train acc:0.9961166666666667

Process finished with exit code 0

准确率打到99%，重要的就是网络结构不一样。