Pytorch 를 이용 하여 권 적 신경 망 을 실현 하 다.

import torch
import torchvision
import torch.utils.data as Data
import torch.nn as nn
from matplotlib import pyplot as plt
import time

#   
BATCH_SIZE=50
LEARNING_RATE=0.001
EPOCH_NUM=3

#    
#torchvision  MNIST      ，      
train_data=torchvision.datasets.MNIST(
    root='./mnist', #root          
    train=True, #       ，True     ，False     
    transform=torchvision.transforms.ToTensor(), #      Tensor  
    download=True #      ，True  ，False   
)

#      
test_data=torchvision.datasets.MNIST(root='./mnist',train=False)

#DataLoader  
train_loader=Data.DataLoader(
    dataset=train_data, #     
    batch_size=BATCH_SIZE, #  batch size
    shuffle=True #        ，True  ，False   
)

#         ，   x,y
# unsqueeze() squeeze()     ，         
#          ，           (dim=1)，          FloatTensor，   2000 ，          

test_x=torch.unsqueeze(test_data.test_data,dim=1).type(torch.FloatTensor)[:2000]/255
test_y=torch.data.test_labels[:2000]


#     
class CNN(nn.Module):
    def __init__(self):
        #                 
        super(CNN,self).__init__()
        #       ，             +    +   
        self.conv1=nn.Sequential(
            #    
            nn.Conv2d(
                in_channels=1, #       ，      1
                out_channels=16, #       16，      16           
                kernel_size=5, #     
                stride=1, #    
                padding=2 #      2               

            ),
            #     
            nn.ReLU()
            #    
            nn.MaxPool2d(kernel_size=2)        
        )
        
        #       
        self.conv2=nn.Sequential(
            nn.Conv2d(
                in_channels=16, #        channel 16，        16
                out_channels=32, #     32
                kernel_size=5,
                stride=1,
                padding=2
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )

        #     ，       28，        2   ，       7*7，  32   ，    32*7*7   ，     10    
        self.out=nn.Linear(32*7*7,10)

    def forward(self,x):
        conv1_res=self.conv1(x)
        conv2_res=self.conv2(conv1_res)
        # view()            Tensor     
        out=conv2_res.view(conv2_res.size(0),-1)
        output=self.out(out)
        return output


#       
cnn=CNN()
print(cnn)

#  Adam    ，         
optimizer=torch.optim.Adam(cnn.parameters(),lr=LEARNING_RATE)
loss_func=nn.CrossEntropyLoss()


#            list
step_list=[]
loss_list=[]
accuracy_list=[]
counter=0

t1=time.time()

for epoch in range(EPOCH_NUM):
    # enumerate                +  
    for step, (b_x,b_y) in enumerate(train_loader):
        predict_y=cnn(b_x)
        loss=loss_func(predict_y,b_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        #        
        counter +=1

        #      
        if step % 25 ==0:
            test_output=cnn(test_x) #        
            pred_y=torch.max(test_output,1)[1].data.squeeze().numpy() #     y
            accuracy=float(torch.sum(pred_y==test_y))/float(test_y.size(0)) #    
            print('epoch:',epoch,'|step:%4d' %step, '|loss:%6f' %loss.data.numpy(),'|accuracy:%4f' %accuracy)

        #      list
        step_list.append(counter)
        loss_list.append(loss.data.numpy())
        accuracy_list.append(accuracy)

        #   
        plt.cla()
        plt.plot(step_list,loss_list, c='red', label='loss')
        plt.plot(step_list,accuracy_list,c='blue',label='accuracy')
        plt.legend(loc='best')
        plt.pause(0.1)

t2=time.time()
print(t2-t1)