美文网首页
Pytorch GoogleNet Fashion-Mnist

Pytorch GoogleNet Fashion-Mnist

作者: hyhchaos | 来源:发表于2018-09-26 22:35 被阅读318次

    pytorch 实现 GoogleNet on Fashion-MNIST

    from __future__ import print_function
    import torch
    import time
    import torch.nn as nn
    import torch.nn.functional as F
    import torchvision
    import torchvision.transforms as transforms
    from torch import optim
    from torch.autograd import Variable
    from torch.utils.data import DataLoader
    from torchvision.transforms import ToPILImage
    show=ToPILImage()
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    #
    batchSize=128
    
    ##load data
    transform = transforms.Compose([transforms.Resize(96),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize, shuffle=True, num_workers=0)
    
    testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, shuffle=False, num_workers=0)
    
    classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
    def imshow(img):
        img = img / 2 + 0.5
        npimg = img.numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
    
    ####network
    def conv_relu(in_channels, out_channels, kernel, stride=1, padding=0):
        layer = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel, stride, padding),
            nn.BatchNorm2d(out_channels, eps=1e-3),
            nn.ReLU(True))
        return layer
    
    
    
    
    class Inception(nn.Module):
        def __init__(self,in_channel,c1,c2,c3,c4):
            super(Inception,self).__init__()
            self.norm1_1=nn.BatchNorm2d(in_channel,eps=1e-3)
            self.p1_1=nn.Conv2d(in_channels=in_channel,out_channels=c1,kernel_size=1)
            self.norm2_1 = nn.BatchNorm2d(in_channel, eps=1e-3)
            self.p2_1=nn.Conv2d(in_channels=in_channel,out_channels=c2[0],kernel_size=1)
            self.norm2_2 = nn.BatchNorm2d(c2[0], eps=1e-3)
            self.p2_2=nn.Conv2d(in_channels=c2[0],out_channels=c2[1],kernel_size=3,padding=1)
            self.norm3_1 = nn.BatchNorm2d(in_channel, eps=1e-3)
            self.p3_1=nn.Conv2d(in_channels=in_channel,out_channels=c3[0],kernel_size=1)
            self.norm3_2 = nn.BatchNorm2d(c3[0], eps=1e-3)
            self.p3_2=nn.Conv2d(in_channels=c3[0],out_channels=c3[1],kernel_size=5,padding=2)
            self.p4_1 = nn.MaxPool2d(kernel_size=3,stride=1,padding=1)
            self.norm4_2 = nn.BatchNorm2d(in_channel, eps=1e-3)
            self.p4_2 = nn.Conv2d(in_channels=in_channel, out_channels=c4, kernel_size=1)
    
        def forward(self, x):
            p1=self.p1_1(F.relu(self.norm1_1(x)))
            p2=self.p2_2(F.relu(self.norm2_2(self.p2_1(F.relu(self.norm2_1(x))))))
            p3=self.p3_2(F.relu(self.norm3_2(self.p3_1(F.relu(self.norm3_1(x))))))
            p4=self.p4_2(F.relu(self.norm4_2(self.p4_1(x))))
            return torch.cat((p1,p2,p3,p4),dim=1)
    
    #Test Inception block
    # test_net = Inception(3, 64, (48, 64), (64, 96), 32)
    # test_x = Variable(torch.zeros(1, 3, 96, 96))
    # print('input shape: {} x {} x {}'.format(test_x.shape[1], test_x.shape[2], test_x.shape[3]))
    # test_y = test_net(test_x)
    # print('output shape: {} x {} x {}'.format(test_y.shape[1], test_y.shape[2], test_y.shape[3]))
    
    
    
    class GoogleNet(nn.Module):
        def __init__(self,in_channel,num_classes):
            super(GoogleNet,self).__init__()
            layers=[]
            layers+=[nn.Conv2d(in_channels=in_channel,out_channels=64,kernel_size=7,stride=2,padding=3),
                     nn.ReLU(),
                     nn.MaxPool2d(kernel_size=3,stride=2,padding=1)]
            layers+=[nn.Conv2d(in_channels=64,out_channels=64,kernel_size=1),
                     nn.Conv2d(in_channels=64,out_channels=192,kernel_size=3,padding=1),
                     nn.MaxPool2d(kernel_size=3,stride=2,padding=1)]
            layers+=[Inception(192,64,(96,128),(16,32),32),
                     Inception(256,128,(128,192),(32,96),64),
                     nn.MaxPool2d(kernel_size=3,stride=2,padding=1)]
            layers+=[Inception(480, 192, (96, 208), (16, 48), 64),
                     Inception(512, 160, (112, 224), (24, 64), 64),
                     Inception(512, 128, (128, 256), (24, 64), 64),
                     Inception(512, 112, (144, 288), (32, 64), 64),
                     Inception(528, 256, (160, 320), (32, 128), 128),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1)]
            layers += [Inception(832, 256, (160, 320), (32, 128), 128),
                       Inception(832, 384, (192, 384), (48, 128), 128),
                       nn.AvgPool2d(kernel_size=2)]
            self.net = nn.Sequential(*layers)
            self.dense=nn.Linear(1024,num_classes)
    
    
        def forward(self,x):
            x=self.net(x)
            x=x.view(-1,1024*1*1)
            x=self.dense(x)
            return x
    
    #Test GoogleNet
    # test_net = GoogleNet(3, 10)
    # test_x = Variable(torch.zeros(1, 3, 96, 96))
    # test_y = test_net(test_x)
    # print('output: {}'.format(test_y.shape))
    
    
    
    net=GoogleNet(1,10).cuda()
    print (net)
    criterion=nn.CrossEntropyLoss()
    optimizer=optim.SGD(net.parameters(),lr=0.1,momentum=0.9)
    
    #train
    print ("training begin")
    for epoch in range(3):
        start = time.time()
        running_loss=0
        for i,data in enumerate(trainloader,0):
            # print (inputs,labels)
            image,label=data
    
    
            image=image.cuda()
            label=label.cuda()
            image=Variable(image)
            label=Variable(label)
    
            # imshow(torchvision.utils.make_grid(image))
            # plt.show()
            # print (label)
            optimizer.zero_grad()
    
            outputs=net(image)
            # print (outputs)
            loss=criterion(outputs,label)
    
            loss.backward()
            optimizer.step()
    
            running_loss+=loss.data
    
            if i%100==99:
                end=time.time()
                print ('[epoch %d,imgs %5d] loss: %.7f  time: %0.3f s'%(epoch+1,(i+1)*batchSize,running_loss/100,(end-start)))
                start=time.time()
                running_loss=0
    print ("finish training")
    
    
    #test
    net.eval()
    correct=0
    total=0
    for data in testloader:
        images,labels=data
        images=images.cuda()
        labels=labels.cuda()
        outputs=net(Variable(images))
        _,predicted=torch.max(outputs,1)
        total+=labels.size(0)
        correct+=(predicted==labels).sum()
    print('Accuracy of the network on the %d test images: %d %%' % (total , 100 * correct / total))
    

    运行过程

    GoogleNet(
      (net): Sequential(
        (0): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))
        (1): ReLU()
        (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
        (3): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))
        (4): Conv2d(64, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (5): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
        (6): Inception(
          (norm1_1): BatchNorm2d(192, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(192, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(96, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(96, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(192, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(192, 16, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(16, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(192, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))
        )
        (7): Inception(
          (norm1_1): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(128, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(128, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(32, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(32, 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (8): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
        (9): Inception(
          (norm1_1): BatchNorm2d(480, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(480, 192, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(480, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(480, 96, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(96, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(96, 208, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(480, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(480, 16, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(16, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(16, 48, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(480, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(480, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (10): Inception(
          (norm1_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(512, 160, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(112, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(112, 224, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(24, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (11): Inception(
          (norm1_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(128, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(24, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (12): Inception(
          (norm1_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(512, 144, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(144, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(144, 288, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(32, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (13): Inception(
          (norm1_1): BatchNorm2d(528, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(528, 256, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(528, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(528, 160, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(160, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(528, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(528, 32, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(32, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(528, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(528, 128, kernel_size=(1, 1), stride=(1, 1))
        )
        (14): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
        (15): Inception(
          (norm1_1): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(832, 256, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(832, 160, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(160, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(832, 32, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(32, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))
        )
        (16): Inception(
          (norm1_1): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p1_1): Conv2d(832, 384, kernel_size=(1, 1), stride=(1, 1))
          (norm2_1): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_1): Conv2d(832, 192, kernel_size=(1, 1), stride=(1, 1))
          (norm2_2): BatchNorm2d(192, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p2_2): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (norm3_1): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_1): Conv2d(832, 48, kernel_size=(1, 1), stride=(1, 1))
          (norm3_2): BatchNorm2d(48, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p3_2): Conv2d(48, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
          (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
          (norm4_2): BatchNorm2d(832, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
          (p4_2): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))
        )
        (17): AvgPool2d(kernel_size=2, stride=2, padding=0)
      )
      (dense): Linear(in_features=1024, out_features=10, bias=True)
    )
    training begin
    [epoch 1,imgs 12800] loss: 0.8332726  time: 7.296 s
    [epoch 1,imgs 25600] loss: 0.4878939  time: 7.260 s
    [epoch 1,imgs 38400] loss: 0.4382473  time: 7.275 s
    [epoch 1,imgs 51200] loss: 0.3879716  time: 7.280 s
    [epoch 2,imgs 12800] loss: 0.3313940  time: 7.340 s
    [epoch 2,imgs 25600] loss: 0.3187236  time: 7.329 s
    [epoch 2,imgs 38400] loss: 0.3174009  time: 7.330 s
    [epoch 2,imgs 51200] loss: 0.2961887  time: 7.328 s
    [epoch 3,imgs 12800] loss: 0.2664629  time: 7.364 s
    [epoch 3,imgs 25600] loss: 0.2510577  time: 7.357 s
    [epoch 3,imgs 38400] loss: 0.2545497  time: 7.354 s
    [epoch 3,imgs 51200] loss: 0.2475178  time: 7.354 s
    finish training
    Accuracy of the network on the 10000 test images: 89 %
    

    相关文章

      网友评论

          本文标题:Pytorch GoogleNet Fashion-Mnist

          本文链接:https://www.haomeiwen.com/subject/rufsoftx.html