GoogleNet的pytorch实现

最新推荐文章于 2024-07-24 11:22:27 发布

Refrain09_23

最新推荐文章于 2024-07-24 11:22:27 发布

阅读量296

点赞数 1

文章标签：卷积神经网络 pytorch ncnn 深度学习神经网络

本文链接：https://blog.csdn.net/qq_41333847/article/details/110140421

版权

在这里插入图片描述

# -*- coding:utf-8 -*-

""" 
作者：Refrain
日期：2020.11.24
内容：GoogLeNet with PyTorch.
"""

import torch.nn as nn
import torch

class Inception(nn.Module):
    def __init__(self,in_planes,n1x1,n3x3red,n3x3,n5x5red,n5x5,pool_planes):
        #n1x1代表卷积核的channel数
        #n3x3代表在3*3卷积核之前的1*1的卷积核的channel数
        #pool_planes代表maxpool之后的1*1卷积核的channel数
        super(Inception,self).__init__()

        self.b1_1x1=nn.Sequential(
            nn.Conv2d(in_channels=in_planes,out_channels=n1x1,kernel_size=1),
            nn.BatchNorm2d(n1x1),
            nn.ReLU(True)

        )

        self.b2_3x3=nn.Sequential(
            nn.Conv2d(in_planes,n3x3red,kernel_size=1),
            nn.BatchNorm2d(n3x3red),
            nn.ReLU(True),
            nn.Conv2d(n3x3red,n3x3,padding=1,kernel_size=3),
            nn.BatchNorm2d(n3x3),
            nn.ReLU(True),
        )

        self.b3_5x5=nn.Sequential(
            nn.Conv2d(in_planes,n5x5red,kernel_size=1),
            nn.BatchNorm2d(n5x5red),
            nn.ReLU(True),
            nn.Conv2d(n5x5red,n5x5,padding=2,kernel_size=5),
            nn.BatchNorm2d(n5x5),
            nn.ReLU(True),
        )

        self.b4_pool=nn.Sequential(
            nn.MaxPool2d(3,stride=1,padding=1,ceil_mode=True),
            nn.Conv2d(in_planes,pool_planes,kernel_size=1),
            nn.BatchNorm2d(pool_planes),
            nn.ReLU(pool_planes)
        )

    def forward(self,input):
        y1=self.b1_1x1(input)
        y2=self.b2_3x3(input)
        y3=self.b3_5x5(input)
        y4=self.b4_pool(input)
        y5=torch.cat([y1,y2,y3,y4],1)

        return  y5


class GoogleNet(nn.Module):
    def __init__(self):
        super(GoogleNet, self).__init__()
        self.pre_layer=nn.Sequential(
            nn.Conv2d(3,64,kernel_size=7,padding=3),#padding怎么确定
            nn.BatchNorm2d(192),
            nn.ReLU(True),
            nn.MaxPool2d(3,stride=2,ceil_mode=True),
            nn.Conv2d(64,64,kernel_size=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.Conv2d(64, 192, kernel_size=3,padding=1),
            nn.BatchNorm2d(192),
            nn.ReLU(True),
            nn.MaxPool2d(3, stride=2,ceil_mode=True),
        )

        self.inceptiona3=Inception(192, 64, 96, 128, 16, 32, 32)
        self.inceptionb3=Inception(256, 128, 128, 192, 32, 96, 64)

        self.maxpool3=nn.MaxPool2d(3,stride=1)

        self.inceptiona4 = Inception(480, 192, 96, 208, 16, 48, 64)
        self.inceptionb4 = Inception(512, 160, 112, 224, 24, 64, 64)
        self.inceptionc4 = Inception(512, 128, 128, 256, 24, 64, 64)
        self.inceptiond4 = Inception(512, 112, 144, 288, 32, 64, 64)
        self.inceptione4 = Inception(528, 256, 160, 320, 32, 128, 128)

        self.maxpool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.inceptiona5 = Inception(832, 256, 160, 320, 32, 128, 128)
        self.inceptionb5 = Inception(832, 384, 192, 384, 48, 128, 128)

        self.avgpool = nn.AvgPool2d(8, stride=1)
        self.linear = nn.Linear(1024, 10)

    def forward(self,x):
        out=self.pre_layer(x)
        out=self.inceptiona3(out)
        out=self.inceptionb3(out)
        out=self.maxpool3(out)
        out=self.inceptiona4(out)
        out= self.inceptionb4(out)
        out= self.inceptionc4(out)
        out= self.inceptiond4(out)
        out= self.inceptione4(out)
        out = self.maxpool4(out)
        out = self.inceptiona5(out)
        out = self.inceptionb5(out)

        out=self.avgpool(out)
        out=self.linear(out)

        return out