Deep learing------Google net网络结构

上面的就是googlenet的网络结构,这个网络结构是2014年由Google团队提出的,下面看看怎么实现:

代码在下面:

import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pylab as plt
from torchvision import datasets
from torch.utils.data import DataLoader
from torchvision import transforms
import numpy as np
#开始读取数据集
transform=transforms.Compose([transforms.ToTensor()])
Batch_size=64
path='./cifar'
train_data=datasets.CIFAR10(root=path,download=True,train=True,transform=transform)
train_loader=DataLoader(train_data,batch_size=Batch_size,shuffle=True)
#测试数据集
test_data=datasets.CIFAR10(root=path,download=True,train=False,transform=transform)
test_loader=DataLoader(test_data,batch_size=Batch_size,shuffle=True)
#开始搭建Google——net
#要保证图像的宽和高不能改变
#cov_1x1=nn.Conv2d(3,16,kernel_size=1)
#cov24_5x5=nn.Conv2d(16,24,kernel_size=5,padding=2)
#cov24_3x3=nn.Conv2d(16,24,kernel_size=3)
#cov24_3x3_2=nn.Conv2d(24,24,kernel_size=3,padding=2)
#cov=nn.Conv2d(3,24,kernel_size=1)
#for index,data in enumerate(test_loader):
    #input,ta=data
    #测试池化的输出
    #out=F.avg_pool2d(input,kernel_size=3,stride=1,padding=1)
    #print(out.shape)
class Google(nn.Module):
    def __init__(self,input_chan):
        super(Google,self).__init__()
        self.cov_1x1=nn.Conv2d(input_chan,16,kernel_size=1)
        self.cov24_5x5=nn.Conv2d(16,24,kernel_size=5,padding=2)
        self.cov_1x1_24=nn.Conv2d(input_chan,16,kernel_size=1)
        self.cov24_3x3=nn.Conv2d(16,24,kernel_size=3)
        self.cov24_3x3_2=nn.Conv2d(24,24,kernel_size=3,padding=2)
        #定义池化层
        self.pool=nn.Conv2d(input_chan,24,kernel_size=1)
    def forward(self,x):
        hid1=self.cov_1x1(x)
        hid2=self.cov24_5x5(self.cov_1x1(x))
        hid3=self.cov24_3x3_2(self.cov24_3x3(self.cov_1x1(x)))
           hid4=F.avg_pool2d(x,kernel_size=3,stride=1,padding=1)
           hid4=self.pool(hid4)
           out=[hid1,hid2,hid3,hid4]
           return torch.cat(out,dim=1)#沿着通道进行拼接
#net=Google(3)
#for index,data in enumerate(test_loader):
    #input,targ=data
    #out=net(input)
    #print(out.shape)#90112,通道数是88
#开始构建网络
cov1=nn.Conv2d(3,10,kernel_size=5)
cov2=nn.Conv2d(88,20,kernel_size=5)
Google1=Google(input_chan=10)
Google2=Google(input_chan=20)
pooling=nn.MaxPool2d(2)
#for index,data in enumerate(test_loader):
    #input,tar=data
    #out=Google1(pooling(cov1(input)))
    #out=Google2(pooling(cov2(out)))
    #print(out.shape)#[64,88,5,5]
num=88*5*5
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.cov1=nn.Conv2d(3,10,kernel_size=5)
        self.cov2=nn.Conv2d(88,20,kernel_size=5)
        self.Google1=Google(input_chan=10)
        self.Google2=Google(input_chan=20)
        self.pooling=nn.MaxPool2d(2)
        self.out=nn.Linear(num,10)
        
    def forward(self,x):
        n_size=x.size(0)
        x=self.Google1(F.relu(self.pooling(self.cov1(x))))
        x=self.Google2(F.relu(self.pooling(self.cov2(x))))
        x=x.view(n_size,-1)
        x=self.out(x)
        return x
#定义优化器开始训练
net=Net()
optizmer=torch.optim.SGD(net.parameters(),lr=0.01)
loss_fun=nn.CrossEntropyLoss()
def train(num):
    runing_loss=0.0
    for index,data in enumerate(train_loader,0):
        input_num,target=data
        optizmer.zero_grad()
        out=net(input_num)
        loss=loss_fun(out,target)
        runing_loss+=loss.item()
        loss.backward()
        optizmer.step()
        if index%300==299:
            print('(CNN)第{}次训练误差是{}'.format(num+1,runing_loss/300))
            runing_loss=0.0
def test():
    right=0#正确的数量
    total=0#总数一共是多少
    with torch.no_grad():
        for data in test_loader:
            image,label=data
            test_out=net(image)
            _,pre=torch.max(test_out.data,dim=1)
            total+=label.size(0)#每一轮对64个图片进行测试
            right+=(pre==label).sum().item()#64个图片中正确预测到的有多少个
        print('Correct rate is {}%'.format(100*(right/total)))
if __name__=='__main__':
    for i in range(100):
        train(i)
        test()