【动手学深度学习】--15.含并行连结的网络GoogLeNet

**动手学深度学习 --15. 含并行连接的网络 GoogLeNet**

在前面的章节中，我们已经学习了多种深度学习模型，如卷积神经网络（CNN）、残差网络（ResNet）等。然而，GoogLeNet是另一种非常有趣且实用的网络结构，它能够有效地利用并行连接来提高计算效率。

**1. GoogLeNet 的基本结构**

GoogLeNet 由多个模块组成，每个模块都包含一个卷积层和一个池化层。这些模块之间通过并行连接进行关联，形成了一个深度网络。

下图是 GoogLeNet 的基本结构：

 +---------------+
 | Conv2d_1a |
 +---------------+
 |
 |
 v +---------------+
 | MaxPool2d_1a |
 +---------------+
 |
 |
 v +---------------+---------------+
 | Inception_3b | Inception_4e |
 +---------------+---------------+
 | |
 | |
 v v +---------------+---------------+
 | MaxPool2d_5a | MaxPool2d_6a |
 +---------------+---------------+
 |
 |
 v +---------------+
 | Conv2d_7b |
 +---------------+

 +---------------+---------------+---------------+
 | Conv2d_1x1 | Conv2d_3x3 | Conv2d_5x5 |
 +---------------+---------------+---------------+
 | | |
 v v v +---------------+---------------+---------------+
 | MaxPool2d_3x3 | MaxPool2d_3x3 | MaxPool2d_3x3 |
 +---------------+---------------+---------------+

import torchimport torch.nn as nnclass GoogLeNet(nn.Module):
 def __init__(self):
 super(GoogLeNet, self).__init__()
 self.conv1 = nn.Conv2d(3,64, kernel_size=7, stride=2, padding=3)
 self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
 self.inception3b = InceptionModule(64,128,192,256)
 self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
 self.inception4e = InceptionModule(512,1024,1536,2048)

 def forward(self, x):
 x = self.conv1(x)
 x = self.maxpool1(x)
 x = self.inception3b(x)
 x = self.maxpool3(x)
 x = self.inception4e(x)
 return xclass InceptionModule(nn.Module):
 def __init__(self, in_channels, out_channels_1x1, out_channels_3x3, out_channels_5x5):
 super(InceptionModule, self).__init__()
 self.conv1x1 = nn.Conv2d(in_channels, out_channels_1x1, kernel_size=1)
 self.conv3x3 = nn.Conv2d(in_channels, out_channels_3x3, kernel_size=3, padding=1)
 self.conv5x5 = nn.Conv2d(in_channels, out_channels_5x5, kernel_size=5, padding=2)

 def forward(self, x):
 x1 = self.conv1x1(x)
 x2 = self.conv3x3(x)
 x3 = self.conv5x5(x)
 return torch.cat((x1, x2, x3), dim=1)

# 初始化模型和损失函数model = GoogLeNet()
criterion = nn.CrossEntropyLoss()

# 初始化优化器optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 训练模型for epoch in range(10):
 for x, y in train_loader:
 optimizer.zero_grad()
 output = model(x)
 loss = criterion(output, y)
 loss.backward()
 optimizer.step()

# 测试模型model.eval()
with torch.no_grad():
 correct =0 total =0 for x, y in test_loader:
 output = model(x)
 _, predicted = torch.max(output, dim=1)
 total += y.size(0)
 correct += (predicted == y).sum().item()

accuracy = correct / totalprint('Test accuracy: {:.2f}%'.format(100. * accuracy))