Resumen de puntos de innovación de GoogLeNet

  GoogLeNet es una arquitectura de red neuronal convolucional profunda propuesta por el equipo de Google en 2014. Es el modelo campeón del concurso ILSVRC (ImageNet Large Scale Visual Recognition Challenge). Sus innovaciones se concentran principalmente en los siguientes aspectos: Módulo de inicio: introducido
  por GoogLeNet Se utiliza el módulo Inception, que utiliza núcleos de convolución y capas de agrupación de diferentes tamaños para capturar características de diferentes escalas. El módulo Inception procesa internamente datos de entrada a través de múltiples capas de convolución paralelas y capas de agrupación, y luego empalma sus salidas, aumentando así la capacidad de la red para percibir características de diferentes escalas. Esta estructura ayuda a mejorar el poder expresivo de la red al tiempo que reduce la cantidad de parámetros.

import torch.nn as nn
import torch
import torch.nn.functional as F

'''step1: 写一个包含卷积层和relu激活函数模块的类'''
class Conv_relu(nn.Module):
    def __init__(self,in_channels,out_channels,**kwargs):
        super(Conv_relu, self).__init__()
        self.conv=nn.Conv2d(in_channels,out_channels,**kwargs)
        self.relu=nn.ReLU(inplace=True)

    def forward(self,x):
        x=self.conv(x)
        x=self.relu(x)
        return x

'''step2: 构建Inception模块,包含4个分支
   branch1：1×1卷积
   branch2：1×1卷积降维-->3×3卷积
   branch3：1×1卷积将为-->5×5卷积
   branch4：3×3最大池化-->1×1降维  
'''
class Inception(nn.Module):
    def __init__(self,in_channels,out_channels1x1,reduce_channels3x3,out_channels3x3,
                 reduce_channels5x5,out_channels5x5,out_channels1x1_pool,):
        super(Inception, self).__init__()

        #branch1：1×1卷积
        self.branch1=Conv_relu(in_channels,out_channels1x1,kernel_size=1)

        #branch2：1×1卷积降维-->3×3卷积
        self.branch2 =nn.Sequential(
            Conv_relu(in_channels, reduce_channels3x3, kernel_size=1),
            Conv_relu(reduce_channels3x3,out_channels3x3,kernel_size=3,padding=1)
        )

        #branch3：1×1卷积将为-->5×5卷积
        self.branch3 =nn.Sequential(
            Conv_relu(in_channels, reduce_channels5x5, kernel_size=1),
            Conv_relu(reduce_channels5x5,out_channels5x5,kernel_size=5,padding=2)
        )

        #branch4：3×3最大池化-->1×1降维
        self.branch4 =nn.Sequential(
            nn.MaxPool2d(kernel_size=3,stride=1,padding=1),
            Conv_relu(in_channels,out_channels1x1_pool,kernel_size=1)
        )

    def forward(self,x):
        x1=self.branch1(x)
        x2 = self.branch2(x)
        x3 = self.branch3(x)
        x4 = self.branch4(x)

        x=torch.cat([x1,x2,x3,x4],dim=1)

        return  x

        # return x1,x2,x3,x4,x

if __name__ == '__main__':

    inc_=Inception(192, 64, 96, 128, 16, 32, 32)

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    inc_.to(device)

    input_tensor=torch.randn(1,192,64,64).to(device)

    # out1,out2,out3,out4,out=inc_(input_tensor)
    out = inc_(input_tensor)
    # print('branch1特征图尺寸:', out1.size())
    # print('branch2特征图尺寸:', out2.size())
    # print('branch3特征图尺寸:', out3.size())
    # print('branch4特征图尺寸:', out4.size())
    print('拼接后的特征图尺寸:', out.size())

  Uso de convolución 1x1: GoogLeNet utiliza ampliamente la convolución 1x1 en el módulo Inception. La convolución 1x1 se puede utilizar para combinar características linealmente, reduciendo así las dimensiones de las características y reduciendo la carga computacional. Esta técnica, conocida como "estructura de cuello de botella", puede aumentar la profundidad y el ancho de la red sin introducir una carga computacional excesiva.
   Agrupación promedio global: en las redes neuronales convolucionales tradicionales, generalmente se usan capas completamente conectadas para la clasificación, lo que da como resultado una gran cantidad de parámetros y cálculos. GoogLeNet utiliza una agrupación promedio global para reemplazar la capa completamente conectada. Al promediar todos los canales del mapa de características, se genera un vector de características y luego se usa un clasificador softmax para la clasificación. Este enfoque reduce la cantidad de parámetros, evita el sobreajuste y reduce la complejidad computacional.
  Clasificadores auxiliares: GoogLeNet introduce dos clasificadores auxiliares, que están conectados a diferentes posiciones en la capa intermedia. Estos clasificadores auxiliares introducen funciones de pérdida adicionales durante el proceso de entrenamiento para ayudar a que la red se entrene más rápido. Durante la fase de prueba, estos clasificadores auxiliares están inactivos y solo se utiliza la salida del clasificador principal. Esta estructura ayuda a aliviar el problema del gradiente que desaparece y promueve la propagación de gradientes en la red.

# 辅助分类器
import torch.nn as nn
import torch
import torch.nn.functional as F

class Aux_classifier(nn.Module):
    def __init__(self,in_channels,num_classes):
        super(Aux_classifier, self).__init__()
        self.avgpool=nn.AvgPool2d(kernel_size=5, stride=3)
        self.conv=Conv_relu(in_channels,128)
        self.fc1 = nn.Linear(2048, 1024)
        self.fc2 = nn.Linear(1024, num_classes)

    def forward(self,x):
        x=self.avgpool(x)
        x=self.conv(x)
        x=torch.flatten(x,1)

        x=F.dropout(x,0.5,training=self.training)
        x=F.relu(self.fc1(x),inplace=True)

        x=F.dropout(x,0.5,training=self.training)
        x=self.fc2(x)
        return x

  En resumen, GoogLeNet construyó con éxito una red más profunda y amplia con poderosas capacidades de extracción y clasificación de características mediante la introducción de innovaciones como el módulo Inception, convolución 1x1, agrupación promedio global y clasificadores auxiliares. Se lograron resultados notables en la competencia de clasificación. Estas innovaciones también proporcionan una inspiración importante para el diseño posterior de redes neuronales profundas.