No module named MNIST_基于pytorch卷积神经网络CNN的MNIST手写数字识别，程序及其最详细注释。...

#1必要加载的库
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets,transforms#2定义超参数
BATCH_SIZE=100 #每批处理的数据
DEVICE=torch.device("cuda"if torch.cuda.is_available() else "cpu")#是否用GPU
EPOCHS=10 #训练数据集的轮次#3构建pipeline,对图像处理
pipline=transforms.Compose([
transforms.ToTensor(),#将图片转成Tensor
transforms.Normalize((0.1307,),(0.3081,))#正则化降低模型复杂度，从官网来的数据
])#4下载数据，加载数据
from torch.utils.data import DataLoader#4.1下载数据集
train_set=datasets.MNIST("data", train=True, download=True, transform=pipline)
test_set=datasets.MNIST("data", train=False, download=True, transform=pipline)#4.2加载数据
train_loader=DataLoader(train_set,batch_size=BATCH_SIZE,shuffle=True)#shuffle打乱数据
test_loader=DataLoader(test_set,batch_size=BATCH_SIZE,shuffle=True)#5构建网络模型
class Digit(nn.Module):
def __init__(self):
super().__init__()
self.conv1=nn.Conv2d(1,10,5) #1表示灰度图片的通道，10输入通道，5卷积层
self.conv2=nn.Conv2d(10,20,3) #10输入通道 20 输出通道 3卷积层kernel #内核(kernel)实则就是一个小的矩阵(一般为1*1,3*3,5*5)，通过扫描图片来进行重新计算，计算方法为矩阵相乘后并将各个元素相加，得到新的像素值。
self.fc1=nn.Linear(20*10*10,500) #20*10*10:输入通道，500：输出通道kernel
self.fc2=nn.Linear(500,10) #500:输入通道，10：输出通道
def forward(self,x):
imput_size=x.size(0) #batch_size
x=self.conv1(x) #输入：batch*1*28*28,输出：batch*10*24*24 (28-5+1=24)
x=F.relu(x)#保持形状不变输出batch*10*24*24 #激活函数：在所有的隐藏层添加一个激活函数，这样的输入就是一个非线性函数，因而神经网络的表达能力更强
x=F.max_pool2d(x,2,2)#输入batch*10*24*24，输出batch*10*12*12 #降采样（最大采样）
x=self.conv2(x) #输入batch*10*12*12，输出：batch*20*10*10(12-3+1=10)
x=F.relu(x)#激活函数
x=x.view(imput_size,2000) #拉平，-1:自动计算维度：20*10*10=2000
x=self.fc1(x) #输入：batch*2000 输出：batch*500
x=F.relu(x) #激活，保持shape不变
x=self.fc2(x) # 输入batch*500 输出batch*10
output=F.log_softmax(x,dim=1)#损失函数，计算分类后的每个数字的概率值 dim表示按行
return output#6定义优化器
model=Digit().to(DEVICE)#定义模型
optimizer=optim.Adam(model.parameters())#创建一个优化器#7定义训练方法
def train_model(model,device,train_loader,optimizer,epoch):#训练模型
model.train()
for batch_index, (data ,target) in enumerate(train_loader):#部署到DEVICE上去
data, target=data.to(device), target.to(device)#梯度初始化为0
optimizer.zero_grad()#训练后的结果
output = model(data)#计算损失
loss=F.cross_entropy(output,target)#找到概率值最大的下标
pred=output.max(1, keepdim=True)#反向传播
loss.backward()#参数优化
optimizer.step()
if batch_index % 3000 == 0:
print("Train Epoch ：{}t Loss:{:.6f}".format(epoch,loss.item()))#定义测试方法
def test_model(model, device,test_loader):#模型验证
model.eval()#正确率
correct= 0.0#测试损失
test_loss= 0.0
with torch.no_grad():#不会计算梯度，也不会进行反向传播
for data, target in test_loader:# 部署到device上
data, target=data.to(device), target.to(device)#测试数据
output = model(data)#计算测试损失
test_loss += F.cross_entropy(output, target).item()#找到概率最大的下标
pred = torch.max(output,dim=1)#累计正确的值
correct += pred.eq(target.view_as(pred)).sum.item()
test_loss /= len(test_loader.dataset)
print("Test --Average loss :{;.4f},Accuracy : {:.3f}n".format(test_loss,100.0 * correct / len(test_loader.dataset)))#调用方法
for epoch in range(1,EPOCHS+1):
train_model(model,DEVICE,train_loader,optimizer,epoch)
test_model(model, DEVICE, test_loader)