昨天我们学习了GoogLeNet的论文,今天我们就来复现一下代码吧！话不多说，讲解都在注释里。（这可能是全网最详细的注释哦）
第一步：定义基础卷积模块（卷积+ReLU+前向传播函数）
'''-------------------第一步：定义基础卷积模块（卷积+ReLU+前向传播函数）--------------''' class BasicConv2d(nn.Module): # init()：进行初始化，申明模型中各层的定义 def __init__(self, in_channels, out_channels, **kwargs): ''' :param in_channels: 输入特征矩阵的深度 :param out_channels:输出特征矩阵的深度 :param kwargs:*args代表任何多个无名参数，返回的是元组； **kwargs表示关键字参数，所有传入的key=value，返回字典； ''' super(BasicConv2d, self).__init__() #BasicConv2d()：卷积激活 '''卷积层''' self.conv = nn.Conv2d(in_channels, out_channels, **kwargs) '''Relu层''' self.relu = nn.ReLU(inplace=True) # ReLU(inplace=True)：将tensor直接修改，不找变量做中间的传递，节省运算内存，不用多存储额外的变量 '''前向传播函数''' def forward(self, x): x = self.conv(x) x = self.relu(x) return x
第二步：定义Inception模块
'''--------------------------第二步：定义Inception模块----------------------''' class Inception(nn.Module): def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj): super(Inception, self).__init__() '''branch1——单个1x1卷积层''' #使用1*1的卷积核，将(Hin,Win,in_channels)-> (Hin,Win,ch1x1)，特征图大小不变，主要改变的是通道数得到第一张特征图(Hin,Win,ch1x1)。 self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1) '''branch2——1x1卷积层后接3x3卷积层''' #先使用1*1的卷积核，将(Hin,Win,in_channels)-> (Hin,Win,ch3x3red)，特征图大小不变，缩小通道数，减少计算量，然后在使用大小3*3填充1的卷积核，保持特征图大小不变，改变通道数为ch3x3，得到第二张特征图(Hin,Win,ch3x3)。 self.branch2 = nn.Sequential( BasicConv2d(in_channels, ch3x3red, kernel_size=1), # 保证输出大小等于输入大小 BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1) ) '''branch3——1x1卷积层后接5x5卷积层''' #先使用1*1的卷积核，将(Hin,Win,in_channels)-> (Hin,Win,ch5x5red)，特征图大小不变，缩小通道数，减少计算量，然后在使用大小5*5填充2的卷积核，保持特征图大小不变，改变通道数为ch5x5，得到第三张特征图(Hin,Win,ch5x5)。 self.branch3 = nn.Sequential( BasicConv2d(in_channels, ch5x5red, kernel_size=1), # 保证输出大小等于输入大小 BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2) ) '''branch4——3x3最大池化层后接1x1卷积层''' #先经过最大池化层，因为stride=1，特征图大小不变，然后在使用大小1*1的卷积核，保持特征图大小不变，改变通道数为pool_proj，得到第四张特征图(Hin,Win,pool_proj)。 self.branch4 = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=1, padding=1), BasicConv2d(in_channels, pool_proj, kernel_size=1) ) # forward()：定义前向传播过程,描述了各层之间的连接关系 def forward(self, x): branch1 = self.branch1(x) branch2 = self.branch2(x) branch3 = self.branch3(x) branch4 = self.branch4(x) # 在通道维上拼接输出最终特征图。(Hin,Win,ch1x1+ch1x1+ch5x5+pool_proj) outputs = [branch1, branch2, branch3, branch4] # cat()：在给定维度上对输入的张量序列进行连接操作 return torch.cat(outputs, 1)
第三步：定义辅助分类器InceptionAux
'''---------------------第三步：定义辅助分类器InceptionAux----------------------''' class InceptionAux(nn.Module): def __init__(self, in_channels, num_classes): super(InceptionAux, self).__init__() '''均值池化''' # nn.AvgPool2d(kernel_size=5, stride=3)：平均池化下采样。核大小为5x5，步长为3。 self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3) '''1×1卷积''' self.conv = BasicConv2d(in_channels, 128, kernel_size=1) '''全连接输出''' # nn.Linear(2048, 1024)、nn.Linear(1024, num_classes)：经过两个全连接层得到分类的一维向量。 # 上一层output[batch, 128, 4, 4]，128X4X4=2048 self.fc1 = nn.Linear(2048, 1024) self.fc2 = nn.Linear(1024, num_classes) # 前向传播过程：即如何根据输入x计算返回所需要的模型输出 def forward(self, x): # 输入：aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14 x = self.averagePool(x) # 输入：aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4 x = self.conv(x) # 输入：N x 128 x 4 x 4 x = torch.flatten(x, 1)#torch.flatten(x, 1)：从深度方向对特征矩阵进行推平处理，从三维降到二维。 # 设置.train()时为训练模式，self.training=True x = F.dropout(x, 0.5, training=self.training) # 输入：N x 2048 x = F.relu(self.fc1(x), inplace=True) x = F.dropout(x, 0.5, training=self.training) # 输入：N x 1024 x = self.fc2(x) # 返回值：N*num_classes return x
第四步：搭建GoogLeNet网络
'''-----------------------第四步：搭建GoogLeNet网络-----------------------------''' class GoogLeNet(nn.Module): def __init__(self, num_classes=2, aux_logits=True, init_weights=False): ''' init()：进行初始化，申明模型中各层的定义 :param num_classes: 需要分类的类别个数 :param aux_logits: 训练过程是否使用辅助分类器，init_weights：是否对网络进行权重初始化 :param init_weights:初始化权重 ''' super(GoogLeNet, self).__init__() # aux_logits: 是否使用辅助分类器（训练的时候为True, 验证的时候为False) self.aux_logits = aux_logits '''第一部分：一个卷积层＋一个最大池化层''' self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3) # 最大池化层类MaxPool2d（）参数含义：kernel_size ：表示做最大池化的窗口大小，stride ：步长， padding ：填充，dilation ：控制窗口中元素步幅，return_indices ：布尔类型，返回最大值位置索引， # ceil_mode ：布尔类型，为True，用向上取整的方法，计算输出形状；默认是向下取整。 self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第二部分：两个卷积层＋一个最大池化层''' self.conv2 = BasicConv2d(64, 64, kernel_size=1) self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1) self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第三部分：3a层和3b层＋最大池化层''' self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32) ''' # Inception(192, 64, 96, 128, 16, 32, 32)中参数分别代表输入深度为192的特征矩阵， 第一层卷积核数量为64，输出深度64。 第二层卷积核数量为96，输出深度96。 第三层卷积核数量为128，输出深度128。 第四层卷积核数量为16，输出深度16。 第五层卷积核数量为32，输出深度32。 第六层最大池化输出深度32不变。 ''' self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64) self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第四部分：4a层、4b层、4c层、4d层、4e层＋最大池化层''' self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64) self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64) self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64) self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64) self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128) self.maxpool4 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第五部分：5a层和5b层''' self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128) self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128) # 如果为真，则使用辅助分类器 if self.aux_logits: self.aux1 = InceptionAux(512, num_classes) # aux1传入的深度是来自于inception4a的输出深度，所以为512.即为4a提供分类服务 self.aux2 = InceptionAux(528, num_classes) # aux2传入的深度是来自于inception4d的输出深度，所以为528.即为4d提供分类服务 '''均值池化 ''' # AdaptiveAvgPool2d：自适应平均池化，指定输出（H，W） self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(0.4) '''全连接输出 ''' self.fc = nn.Linear(1024, num_classes) # 如果为真，则对网络参数进行初始化 if init_weights: self._initialize_weights() # forward()：定义前向传播过程,描述了各层之间的连接关系 def forward(self, x): # N x 3 x 224 x 224 x = self.conv1(x) # N x 64 x 112 x 112 x = self.maxpool1(x) # N x 64 x 56 x 56 x = self.conv2(x) # N x 64 x 56 x 56 x = self.conv3(x) # N x 192 x 56 x 56 x = self.maxpool2(x) # N x 192 x 28 x 28 x = self.inception3a(x) # N x 256 x 28 x 28 x = self.inception3b(x) # N x 480 x 28 x 28 x = self.maxpool3(x) # N x 480 x 14 x 14 '''在4a层和4b层、4d和4e层之间会有一个判断：如果使用辅助分类器会调用辅助分类器aux1并返回一个分类结果''' x = self.inception4a(x) # N x 512 x 14 x 14 # 设置.train()时为训练模式，self.training=True if self.training and self.aux_logits: aux1 = self.aux1(x) x = self.inception4b(x) # N x 512 x 14 x 14 x = self.inception4c(x) # N x 512 x 14 x 14 x = self.inception4d(x) # N x 528 x 14 x 14 if self.training and self.aux_logits: aux2 = self.aux2(x) x = self.inception4e(x) # N x 832 x 14 x 14 x = self.maxpool4(x) # N x 832 x 7 x 7 x = self.inception5a(x) # N x 832 x 7 x 7 x = self.inception5b(x) # N x 1024 x 7 x 7 '''最终分类部分''' '''由平均池化层+dropout+全连接层输出x， 如果使用到辅助分类器就输出x, aux2, aux1。 其中采用了平均池化层来代替全连接层,事实证明这样可以提高准确率0.6%。 最后还是加了一个全连接层，主要是为了方便对输出进行灵活调整。''' x = self.avgpool(x) # N x 1024 x 1 x 1 x = torch.flatten(x, 1) # N x 1024 x = self.dropout(x) x = self.fc(x) '''最后在全连接层之后还会有一个判断：判断模型若处于训练状态并且调用辅助分类器则返回3个结果：主分类结果，分类器1和分类器2生成的分类结果。''' # N x 1000 (num_classes) if self.training and self.aux_logits: return x, aux2, aux1 return x
第五步*：网络结构参数初始化
'''-----------------------网络结构参数初始化--------------------------''' #目的：使网络更好收敛，准确率更高 def _initialize_weights(self):# 将各种初始化方法定义为一个initialize_weights()的函数并在模型初始后进行使用。 # 遍历网络中的每一层 for m in self.modules(): # isinstance(object, type)，如果指定的对象拥有指定的类型，则isinstance()函数返回True '''如果是卷积层Conv2d''' if isinstance(m, nn.Conv2d): # Kaiming正态分布方式的权重初始化 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') '''判断是否有偏置：''' # 如果偏置不是0，将偏置置成0，对偏置进行初始化 if m.bias is not None: # torch.nn.init.constant_(tensor, val)，初始化整个矩阵为常数val nn.init.constant_(m.bias, 0) '''如果是全连接层''' elif isinstance(m, nn.Linear): # init.normal_(tensor, mean=0.0, std=1.0)，使用从正态分布中提取的值填充输入张量 # 参数：tensor：一个n维Tensor，mean：正态分布的平均值，std：正态分布的标准差 nn.init.normal_(m.weight, 0, 0.01) nn.init.constant_(m.bias, 0)
效果展示
完整代码
import torch import torch.nn as nn import torch.nn.functional as F # noinspection PyUnresolvedReferences from torchsummary import summary #torchsummary功能：查看网络层形状、参数 '''-------------------------第一步：定义基础卷积模块（卷积+ReLU+前向传播函数）--------''' class BasicConv2d(nn.Module): # init()：进行初始化，申明模型中各层的定义 def __init__(self, in_channels, out_channels, **kwargs): ''' :param in_channels: 输入特征矩阵的深度 :param out_channels:输出特征矩阵的深度 :param kwargs:*args代表任何多个无名参数，返回的是元组；**kwargs表示关键字参数，所有传入的key=value，返回字典； ''' super(BasicConv2d, self).__init__()#BasicConv2d()：卷积激活 '''卷积层''' self.conv = nn.Conv2d(in_channels, out_channels, **kwargs) '''Relu层''' self.relu = nn.ReLU(inplace=True) # ReLU(inplace=True)：将tensor直接修改，不找变量做中间的传递，节省运算内存，不用多存储额外的变量 '''前向传播函数''' def forward(self, x): x = self.conv(x) x = self.relu(x) return x '''-------------------------第二步：定义Inception模块----------------------------''' class Inception(nn.Module): def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj): super(Inception, self).__init__() '''branch1——单个1x1卷积层''' #使用1*1的卷积核，将(Hin,Win,in_channels)-> (Hin,Win,ch1x1)，特征图大小不变，主要改变的是通道数得到第一张特征图(Hin,Win,ch1x1)。 self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1) '''branch2——1x1卷积层后接3x3卷积层''' #先使用1*1的卷积核，将(Hin,Win,in_channels)-> (Hin,Win,ch3x3red)，特征图大小不变，缩小通道数，减少计算量，然后在使用大小3*3填充1的卷积核，保持特征图大小不变，改变通道数为ch3x3，得到第二张特征图(Hin,Win,ch3x3)。 self.branch2 = nn.Sequential( BasicConv2d(in_channels, ch3x3red, kernel_size=1), # 保证输出大小等于输入大小 BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1) ) '''branch3——1x1卷积层后接5x5卷积层''' #先使用1*1的卷积核，将(Hin,Win,in_channels)-> (Hin,Win,ch5x5red)，特征图大小不变，缩小通道数，减少计算量，然后在使用大小5*5填充2的卷积核，保持特征图大小不变，改变通道数为ch5x5，得到第三张特征图(Hin,Win,ch5x5)。 self.branch3 = nn.Sequential( BasicConv2d(in_channels, ch5x5red, kernel_size=1), # 保证输出大小等于输入大小 BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2) ) '''branch4——3x3最大池化层后接1x1卷积层''' #先经过最大池化层，因为stride=1，特征图大小不变，然后在使用大小1*1的卷积核，保持特征图大小不变，改变通道数为pool_proj，得到第四张特征图(Hin,Win,pool_proj)。 self.branch4 = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=1, padding=1), BasicConv2d(in_channels, pool_proj, kernel_size=1) ) # forward()：定义前向传播过程,描述了各层之间的连接关系 def forward(self, x): branch1 = self.branch1(x) branch2 = self.branch2(x) branch3 = self.branch3(x) branch4 = self.branch4(x) # 在通道维上拼接输出最终特征图。(Hin,Win,ch1x1+ch1x1+ch5x5+pool_proj) outputs = [branch1, branch2, branch3, branch4] # cat()：在给定维度上对输入的张量序列进行连接操作 return torch.cat(outputs, 1) '''---------------------第三步：定义辅助分类器InceptionAux----------------------''' class InceptionAux(nn.Module): def __init__(self, in_channels, num_classes): super(InceptionAux, self).__init__() '''均值池化''' # nn.AvgPool2d(kernel_size=5, stride=3)：平均池化下采样。核大小为5x5，步长为3。 self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3) '''1×1卷积''' self.conv = BasicConv2d(in_channels, 128, kernel_size=1) '''全连接输出''' # nn.Linear(2048, 1024)、nn.Linear(1024, num_classes)：经过两个全连接层得到分类的一维向量。 # 上一层output[batch, 128, 4, 4]，128X4X4=2048 self.fc1 = nn.Linear(2048, 1024) self.fc2 = nn.Linear(1024, num_classes) # 前向传播过程：即如何根据输入x计算返回所需要的模型输出 def forward(self, x): # 输入：aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14 x = self.averagePool(x) # 输入：aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4 x = self.conv(x) # 输入：N x 128 x 4 x 4 x = torch.flatten(x, 1)#torch.flatten(x, 1)：从深度方向对特征矩阵进行推平处理，从三维降到二维。 # 设置.train()时为训练模式，self.training=True x = F.dropout(x, 0.5, training=self.training) # 输入：N x 2048 x = F.relu(self.fc1(x), inplace=True) x = F.dropout(x, 0.5, training=self.training) # 输入：N x 1024 x = self.fc2(x) # 返回值：N*num_classes return x '''-------------------------第四步：GoogLeNet网络----------------------''' class GoogLeNet(nn.Module): def __init__(self, num_classes=2, aux_logits=True, init_weights=False): ''' init()：进行初始化，申明模型中各层的定义 :param num_classes: 需要分类的类别个数 :param aux_logits: 训练过程是否使用辅助分类器，init_weights：是否对网络进行权重初始化 :param init_weights:初始化权重 ''' super(GoogLeNet, self).__init__() # aux_logits: 是否使用辅助分类器（训练的时候为True, 验证的时候为False) self.aux_logits = aux_logits '''第一部分：一个卷积层＋一个最大池化层''' self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3) # 最大池化层类MaxPool2d（）参数含义：kernel_size ：表示做最大池化的窗口大小，stride ：步长， padding ：填充，dilation ：控制窗口中元素步幅，return_indices ：布尔类型，返回最大值位置索引， # ceil_mode ：布尔类型，为True，用向上取整的方法，计算输出形状；默认是向下取整。 self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第二部分：两个卷积层＋一个最大池化层''' self.conv2 = BasicConv2d(64, 64, kernel_size=1) self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1) self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第三部分：3a层和3b层＋最大池化层''' self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32) ''' # Inception(192, 64, 96, 128, 16, 32, 32)中参数分别代表输入深度为192的特征矩阵， 第一层卷积核数量为64，输出深度64。 第二层卷积核数量为96，输出深度96。 第三层卷积核数量为128，输出深度128。 第四层卷积核数量为16，输出深度16。 第五层卷积核数量为32，输出深度32。 第六层最大池化输出深度32不变。 ''' self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64) self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第四部分：4a层、4b层、4c层、4d层、4e层＋最大池化层''' self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64) self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64) self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64) self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64) self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128) self.maxpool4 = nn.MaxPool2d(3, stride=2, ceil_mode=True) '''第五部分：5a层和5b层''' self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128) self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128) # 如果为真，则使用辅助分类器 if self.aux_logits: self.aux1 = InceptionAux(512, num_classes) # aux1传入的深度是来自于inception4a的输出深度，所以为512.即为4a提供分类服务 self.aux2 = InceptionAux(528, num_classes) # aux2传入的深度是来自于inception4d的输出深度，所以为528.即为4d提供分类服务 '''均值池化 ''' # AdaptiveAvgPool2d：自适应平均池化，指定输出（H，W） self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(0.4) '''全连接输出 ''' self.fc = nn.Linear(1024, num_classes) # 如果为真，则对网络参数进行初始化 if init_weights: self._initialize_weights() # forward()：定义前向传播过程,描述了各层之间的连接关系 def forward(self, x): # N x 3 x 224 x 224 x = self.conv1(x) # N x 64 x 112 x 112 x = self.maxpool1(x) # N x 64 x 56 x 56 x = self.conv2(x) # N x 64 x 56 x 56 x = self.conv3(x) # N x 192 x 56 x 56 x = self.maxpool2(x) # N x 192 x 28 x 28 x = self.inception3a(x) # N x 256 x 28 x 28 x = self.inception3b(x) # N x 480 x 28 x 28 x = self.maxpool3(x) # N x 480 x 14 x 14 '''在4a层和4b层、4d和4e层之间会有一个判断：如果使用辅助分类器会调用辅助分类器aux1并返回一个分类结果''' x = self.inception4a(x) # N x 512 x 14 x 14 # 设置.train()时为训练模式，self.training=True if self.training and self.aux_logits: aux1 = self.aux1(x) x = self.inception4b(x) # N x 512 x 14 x 14 x = self.inception4c(x) # N x 512 x 14 x 14 x = self.inception4d(x) # N x 528 x 14 x 14 if self.training and self.aux_logits: aux2 = self.aux2(x) x = self.inception4e(x) # N x 832 x 14 x 14 x = self.maxpool4(x) # N x 832 x 7 x 7 x = self.inception5a(x) # N x 832 x 7 x 7 x = self.inception5b(x) # N x 1024 x 7 x 7 '''最终分类部分''' '''由平均池化层+dropout+全连接层输出x， 如果使用到辅助分类器就输出x, aux2, aux1。 其中采用了平均池化层来代替全连接层,事实证明这样可以提高准确率0.6%。 最后还是加了一个全连接层，主要是为了方便对输出进行灵活调整。''' x = self.avgpool(x) # N x 1024 x 1 x 1 x = torch.flatten(x, 1) # N x 1024 x = self.dropout(x) x = self.fc(x) '''最后在全连接层之后还会有一个判断：判断模型若处于训练状态并且调用辅助分类器则返回3个结果：主分类结果，分类器1和分类器2生成的分类结果。''' # N x 1000 (num_classes) if self.training and self.aux_logits: return x, aux2, aux1 return x '''-------------------------------网络结构参数初始化---------------------------''' #目的：使网络更好收敛，准确率更高 def _initialize_weights(self):# 将各种初始化方法定义为一个initialize_weights()的函数并在模型初始后进行使用。 # 遍历网络中的每一层 for m in self.modules(): # isinstance(object, type)，如果指定的对象拥有指定的类型，则isinstance()函数返回True '''如果是卷积层Conv2d''' if isinstance(m, nn.Conv2d): # Kaiming正态分布方式的权重初始化 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') '''判断是否有偏置：''' # 如果偏置不是0，将偏置置成0，对偏置进行初始化 if m.bias is not None: # torch.nn.init.constant_(tensor, val)，初始化整个矩阵为常数val nn.init.constant_(m.bias, 0) '''如果是全连接层''' elif isinstance(m, nn.Linear): # init.normal_(tensor, mean=0.0, std=1.0)，使用从正态分布中提取的值填充输入张量 # 参数：tensor：一个n维Tensor，mean：正态分布的平均值，std：正态分布的标准差 nn.init.normal_(m.weight, 0, 0.01) nn.init.constant_(m.bias, 0) if __name__ == '__main__': # 随机输入，测试网络结构是否通 net = GoogLeNet(num_classes=2).cuda() summary(net, (3, 224, 224))
以上就是InceptionV1的代码复现
相关链接：GoogLeNet InceptionV3代码复现＋超详细注释（PyTorch）
有什么问题欢迎大家留言讨论呀~
