Deep learning has become one of the most important technologies in the field of artificial intelligence, and among them, neural networks are widely used to solve various problems. In this course, we will take a closer look at GoogLeNet, a CNN (Convolutional Neural Network). GoogLeNet gained significant attention by winning the ILSVRC (Imagenet Large Scale Visual Recognition Challenge) in 2014.<\/p>\n
GoogLeNet, also known as ‘Inception v1’, has a unique structure that includes multiple convolution layers. Its main feature is the ‘Inception module’, which uses filters of various sizes to process images simultaneously. This approach helps the network learn more information without losing details.<\/p>\n
The Inception module uses multiple filters to capture details at different levels. Each module is composed as follows:<\/p>\n
All these outputs are combined and passed to the next layer. This way, features at various scales can be obtained.<\/p>\n
Now let’s look at how to implement GoogLeNet in PyTorch. First, we need to install PyTorch and other essential libraries.<\/p>\n
pip install torch torchvision<\/code><\/pre>\n3.1 Preparing the Dataset<\/h3>\n
In this example, we will use the CIFAR-10 dataset. This dataset consists of 60,000 images divided into 10 classes.<\/p>\n
\nimport torch\nimport torchvision\nimport torchvision.transforms as transforms\n\n# Define data transformations\ntransform = transforms.Compose(\n [transforms.Resize((224, 224)),\n transforms.ToTensor()])\n\n# Download CIFAR-10 dataset\ntrainset = torchvision.datasets.CIFAR10(root='.\/data', train=True,\n download=True, transform=transform)\ntrainloader = torch.utils.data.DataLoader(trainset, batch_size=32,\n shuffle=True, num_workers=2)\ntestset = torchvision.datasets.CIFAR10(root='.\/data', train=False,\n download=True, transform=transform)\ntestloader = torch.utils.data.DataLoader(testset, batch_size=32,\n shuffle=False, num_workers=2)\n<\/code><\/pre>\n3.2 Defining the GoogLeNet Model<\/h3>\n
Next, we will define the GoogLeNet model. We will write the Inception module to be used.<\/p>\n
\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nclass Inception(nn.Module):\n def __init__(self, in_channels):\n super(Inception, self).__init__()\n self.branch1x1 = nn.Sequential(\n nn.Conv2d(in_channels, 64, kernel_size=1),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True)\n )\n\n self.branch3x3 = nn.Sequential(\n nn.Conv2d(in_channels, 128, kernel_size=1),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True),\n nn.Conv2d(128, 128, kernel_size=3, padding=1),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True)\n )\n\n self.branch5x5 = nn.Sequential(\n nn.Conv2d(in_channels, 32, kernel_size=1),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=5, padding=2),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True)\n )\n\n self.branch_pool = nn.Sequential(\n nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n nn.Conv2d(in_channels, 32, kernel_size=1),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True)\n )\n\n def forward(self, x):\n branch1 = self.branch1x1(x)\n branch3 = self.branch3x3(x)\n branch5 = self.branch5x5(x)\n branch_pool = self.branch_pool(x)\n\n outputs = [branch1, branch3, branch5, branch_pool]\n return torch.cat(outputs, 1)\n<\/code><\/pre>\n3.3 Defining the Full GoogLeNet<\/h3>\n\nclass GoogLeNet(nn.Module):\n def __init__(self, num_classes=10):\n super(GoogLeNet, self).__init__()\n self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)\n self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n\n self.conv2 = nn.Conv2d(64, 192, kernel_size=3, padding=1)\n self.pool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n\n self.inception1 = Inception(192)\n self.inception2 = Inception(256)\n self.inception3 = Inception(480)\n\n self.pool3 = nn.AvgPool2d(kernel_size=7)\n self.fc = nn.Linear(480, num_classes)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n x = self.pool1(x)\n x = F.relu(self.conv2(x))\n x = self.pool2(x)\n\n x = self.inception1(x)\n x = self.inception2(x)\n x = self.inception3(x)\n\n x = self.pool3(x)\n x = x.view(x.size(0), -1)\n x = self.fc(x)\n return x\n\nmodel = GoogLeNet()\n<\/code><\/pre>\n3.4 Defining the Loss Function and Optimizer<\/h3>\n
Now that we are ready to train the model, we will define the loss function and the optimizer.<\/p>\n
\nimport torch.optim as optim\n\ncriterion = nn.CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=0.001)\n<\/code><\/pre>\n3.5 Training the Model<\/h3>\n
Now we will train the model. We will track the loss and accuracy during the given epochs.<\/p>\n
\nnum_epochs = 10\n\nfor epoch in range(num_epochs):\n model.train()\n running_loss = 0.0\n for i, data in enumerate(trainloader, 0):\n inputs, labels = data\n optimizer.zero_grad()\n outputs = model(inputs)\n loss = criterion(outputs, labels)\n loss.backward()\n optimizer.step()\n\n running_loss += loss.item()\n if i % 100 == 99: # Print every 100 batches\n print(f'Epoch [{epoch+1}\/{num_epochs}], Step [{i+1}\/{len(trainloader)}], Loss: {running_loss \/ 100:.4f}')\n running_loss = 0.0\n print('Training complete')\n\nprint('Model training finished!')\n<\/code><\/pre>\n3.6 Evaluating the Model<\/h3>\n
Once training is complete, we will evaluate the model’s performance using the test dataset.<\/p>\n
\ncorrect = 0\ntotal = 0\nmodel.eval()\nwith torch.no_grad():\n for data in testloader:\n images, labels = data\n outputs = model(images)\n _, predicted = torch.max(outputs.data, 1)\n total += labels.size(0)\n correct += (predicted == labels).sum().item()\n\nprint(f'Accuracy: {100 * correct \/ total:.2f}%')\n<\/code><\/pre>\n4. Conclusion<\/h2>\n
GoogLeNet offers a powerful network structure that can leverage features at various scales. In this course, we learned the fundamental concepts of GoogLeNet and how to implement it in PyTorch. With this understanding, you will be able to apply similar methods in more complex models.<\/p>\n
Additionally, there are many variations of GoogLeNet. Models like Inception v2 and Inception v3 improve performance by adjusting the depth or structure of the model. These variations can help achieve even more accurate predictions. In the next course, we will also cover these variant models.<\/p>\n
That concludes the explanation about GoogLeNet. Thank you!<\/p>\n
<\/body><\/p>\n","protected":false},"excerpt":{"rendered":"