Pytorch学习笔记7：MNIST多分类实践

#需要import的lib

import torch
import numpy as np
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

#需要import的lib

print('——————————MNIST多分类实战——————————')
batch_size=200
learning_rate=0.01
epochs=10

train_loader=torch.utils.data.DataLoader(
   datasets.MNIST('../data',train=True,download=True,
                  transform=transforms.Compose(
                      [
                          transforms.ToTensor(),
                          transforms.Normalize((0.1307,),(0.3081,))
                      ]
                  )

   ),
   batch_size=batch_size,shuffle=True #每个batch load的数据，是不是打乱每个batch的数据
)
test_loader=torch.utils.data.DataLoader(
   datasets.MNIST('../data',train=False,
                  transform=transforms.Compose(
                      [
                          transforms.ToTensor(),
                          transforms.Normalize((0.1307,),(0.3081,))
                      ]
                  )

   ),
   batch_size=batch_size,shuffle=True #每个batch load的数据，是不是打乱每个batch的数据
)

w1,b1=torch.randn(200,784,requires_grad=True),\
     torch.zeros(200,requires_grad=True)
w2,b2=torch.randn(200,200,requires_grad=True),\
     torch.zeros(200,requires_grad=True)
w3,b3=torch.randn(10,200,requires_grad=True),\
     torch.zeros(10,requires_grad=True)

torch.nn.init.kaiming_normal_(w1)#用何凯明的方法初始化数据
torch.nn.init.kaiming_normal_(w2)
torch.nn.init.kaiming_normal_(w3)

def forward(x):#定义一个三层全连接层，用relu防止梯度弥散
   x=x@w1.t()+b1
   x=torch.relu(x)
   x=x@w2.t()+b2
   x=torch.relu(x)
   x=x@w3.t()+b3
   return x

optimizer=torch.optim.SGD([w1,b1,w2,b2,w3,b3],lr=learning_rate)#优化器为SGD
criteon=torch.nn.CrossEntropyLoss()#loss函数为交叉熵

for epoch in range(epochs):
   for batch_idx,(data,target) in enumerate(train_loader):
       data=data.view(-1,28*28)

       logits=forward(data) #把数据放入神经网络得出pred的值
       loss=criteon(logits,target) #用loss函数计算pred和target的差
       optimizer.zero_grad() #清零梯度
       loss.backward() #重新计算梯度

       optimizer.step() #用新的梯度计算新的w b，然后迭代

       if batch_idx % 100 == 0:
           #print('epoch:',epoch)
           #print('batch_idx:', batch_idx)
           #print('len data', len(data))
           #print('len(train_loader.dataset)', len(train_loader.dataset))
           #print('len(train_loader)', len(train_loader))
           print(
               'train epoch:{}[{}/{}({:.0f}%)]\tLoss:{:.6f}'.format(
                   epoch,batch_idx * len(data), len(train_loader.dataset),
                   100. * batch_idx / len(train_loader),loss.item()
               )
           )

   test_loss=0
   correct=0
   for data,target in test_loader:
       data=data.view(-1,28*28)
       logits = forward(data)#把数据放入神经网络得出pred的值
       test_loss +=criteon(logits,target).item()#?累加loss

       pred =logits.data.max(1)[1]#得出pred的最大值，就是网络识别出来的数字
       correct +=pred.eq(target.data).sum()#？target.data
   test_loss /=len(test_loader.dataset)
   #print('len(test_loader.dataset):', len(test_loader.dataset))
   print(
       '\ntest set:avg loss:{:.4f},accu:{}/{} ({:.0f}%)\n'.format(
           test_loss,correct,len(test_loader.dataset),
           100.*correct/len(test_loader.dataset)
       )
   )


print('——————————MNIST多分类实战——————————')
print('——————————全连接层——————————')
class MLP(torch.nn.Module):#新建一个MLP名称的类
   def __init__(self):
       super(MLP, self).__init__()
       self.model=torch.nn.Sequential(
           torch.nn.Linear(784,200),
           torch.nn.ReLU(inplace=True),
           torch.nn.Linear(200, 200),
           torch.nn.ReLU(inplace=True),
           torch.nn.Linear(200, 10),
           torch.nn.ReLU(inplace=True),
       )
def forword(self,x):#自定义forword函数
   x=self.model(x)
   return x

net=MLP() #初始化一个MLP类
a=torch.randn(200,784)
b=forword(net,a)#把类名称传递给函数
print(b.shape)
print('——————————全连接层——————————')