Ctrl+K

googleNet

googleNet#

Overview#

GoogLeNet, also known as Inception v1, is a convolutional neural network architecture developed by researchers at Google. It was the winner of the ILSVRC 2014 competition, showcasing a significant improvement in both performance and computational efficiency compared to previous architectures like AlexNet and VGG. The key innovation in GoogLeNet is the introduction of the “Inception module,” which allows the network to capture features at multiple scales.

Architecture#

The architecture of GoogLeNet is deeper and more complex than its predecessors, consisting of 22 layers (27 layers including pooling) but with significantly fewer parameters, thanks to the efficient design of the Inception modules.

Inception Module#

The Inception module is the building block of GoogLeNet and comprises several parallel convolutional and pooling operations:

  1. 1x1 Convolution: Reduces dimensionality and computational cost.

  2. 3x3 Convolution: Captures medium-scale features.

  3. 5x5 Convolution: Captures large-scale features.

  4. 3x3 Max Pooling: Reduces spatial dimensions and extracts dominant features.

These operations are concatenated along the channel dimension, allowing the network to process information at different scales simultaneously.

Detailed Layer Breakdown#

GoogLeNet’s overall structure is as follows:

  1. Input Layer: (224 \times 224 \times 3) input image.

  2. Conv Layer 1: (7 \times 7) convolution with 64 filters, stride 2, followed by max-pooling.

  3. Conv Layer 2: Two (3 \times 3) convolutions with 192 filters, followed by max-pooling.

  4. Inception Modules: Nine inception modules stacked together, interspersed with max-pooling layers.

  5. Auxiliary Classifiers: Two auxiliary classifiers to improve gradient flow and assist in training.

  6. Global Average Pooling: Reduces the spatial dimensions to 1x1 before the final classification layer.

  7. Fully Connected Layer: A dense layer with 1000 outputs for classification.

Inception Module Breakdown#

Each Inception module includes:

  • (1 \times 1) convolution

  • (3 \times 3) convolution (preceded by (1 \times 1) convolution for dimensionality reduction)

  • (5 \times 5) convolution (preceded by (1 \times 1) convolution for dimensionality reduction)

  • (3 \times 3) max pooling (followed by (1 \times 1) convolution for dimensionality reduction)

Real-World Example#

GoogLeNet has been widely used in various computer vision tasks due to its efficiency and high performance. For example:

  1. Object Detection: Improved detection accuracy in complex scenes.

  2. Image Segmentation: Used in applications requiring detailed object boundaries.

  3. Medical Imaging: Analyzing medical images for diagnosis and treatment planning.

Practical Application#

One of the practical applications of GoogLeNet is in the field of autonomous vehicles, where real-time object detection and classification are critical for safe navigation.

Python Code (PyTorch)#

Here’s a simplified implementation of GoogLeNet’s Inception module and overall architecture using PyTorch:

import torch
import torch.nn as nn

class Inception(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
        super(Inception, self).__init__()
        self.branch1 = nn.Conv2d(in_channels, ch1x1, kernel_size=1)

        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
            nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)
        )

        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
            nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2)
        )

        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, pool_proj, kernel_size=1)
        )

    def forward(self, x):
        branch1 = self.branch1(x)
        branch2 = self.branch2(x)
        branch3 = self.branch3(x)
        branch4 = self.branch4(x)
        outputs = [branch1, branch2, branch3, branch4]
        return torch.cat(outputs, 1)

class GoogLeNet(nn.Module):
    def __init__(self, num_classes=1000):
        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.conv2 = nn.Conv2d(64, 192, kernel_size=3, stride=1, padding=1)
        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
        self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        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(kernel_size=2, stride=2, padding=0)

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

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.dropout = nn.Dropout(0.4)
        self.fc = nn.Linear(1024, num_classes)

    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.inception3a(x)
        x = self.inception3b(x)
        x = self.maxpool3(x)
        x = self.inception4a(x)
        x = self.inception4b(x)
        x = self.inception4c(x)
        x = self.inception4d(x)
        x = self.inception4e(x)
        x = self.maxpool4(x)
        x = self.inception5a(x)
        x = self.inception5b(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.dropout(x)
        x = self.fc(x)
        return x

# Example usage
model = GoogLeNet(num_classes=1000)
print(model)

In this implementation, the Inception class defines the inception module, and the GoogLeNet class assembles the complete network using multiple inception modules and other layers.

Conclusion#

GoogLeNet introduced a novel approach to deep learning architectures with its Inception modules, allowing the network to capture multi-scale features efficiently. This innovation significantly reduced the number of parameters compared to previous architectures while achieving state-of-the-art performance. GoogLeNet has influenced many subsequent architectures and remains a foundational model in the field of computer vision.

Contents