GoogleNet Implementation¶
- VGG¿Í Áߺ¹µÇ´Â ºÎºÐÀº ÁÖ¼®À» »ý·«Çß½À´Ï´Ù.
- 2014 ILSVRC 1nd place
- Inception Module
In [1]:
# ·±Å¸ÀÓ À¯Çü GPU ¸ðµå·Î º¯°æ
!pip install torch torchvision
In [2]:
!rm -r images
import os
try:
os.mkdir("images")
os.mkdir("images/dogs")
os.mkdir("images/cats")
except:
pass
!wget https://i.kinja-img.com/gawker-media/image/upload/s--WFkXeene--/c_scale,f_auto,fl_progressive,q_80,w_800/ol9ceoqxidudap8owlwn.jpg -P images/dogs
!wget https://www.rspcansw.org.au/wp-content/uploads/2017/08/50_a-feature_dogs-and-puppies_mobile.jpg -P images/dogs
!wget https://www.catster.com/wp-content/uploads/2018/05/A-gray-cat-crying-looking-upset.jpg -P images/cats
!wget https://www.scarymommy.com/wp-content/uploads/2018/01/c1.jpg?w=700 -P images/cats
In [0]:
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.init as init
import torch.utils.data as data
import torchvision.datasets as dset
import torchvision.transforms as transforms
#from torch.utils.data import DataLoader
2) Hyperparameter¶
In [0]:
batch_size= 1
learning_rate = 0.0002
num_epoch = 100
2. Data Loader¶
In [0]:
img_dir = "./images"
img_data = dset.ImageFolder(img_dir, transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
]))
train_loader = data.DataLoader(img_data, batch_size=batch_size,
shuffle=True, num_workers=2)
In [0]:
def conv_1(in_dim,out_dim):
model = nn.Sequential(
nn.Conv2d(in_dim,out_dim,1,1),
nn.ReLU(),
)
return model
def conv_1_3(in_dim,mid_dim,out_dim):
model = nn.Sequential(
nn.Conv2d(in_dim,mid_dim,1,1),
nn.ReLU(),
nn.Conv2d(mid_dim,out_dim,3,1,1),
nn.ReLU()
)
return model
def conv_1_5(in_dim,mid_dim,out_dim):
model = nn.Sequential(
nn.Conv2d(in_dim,mid_dim,1,1),
nn.ReLU(),
nn.Conv2d(mid_dim,out_dim,5,1,2),
nn.ReLU()
)
return model
def max_3_1(in_dim,out_dim):
model = nn.Sequential(
nn.MaxPool2d(3,1,1),
nn.Conv2d(in_dim,out_dim,1,1),
nn.ReLU(),
)
return model
2) Inception Module¶
- ¾Õ¼ Á¤ÀÇÇÑ ¿¬»êÀ¸·Î ÀμÁ¼Ç ¸ðµâÀ» ¸¸µê´Ï´Ù.
In [0]:
class inception_module(nn.Module):
def __init__(self,in_dim,out_dim_1,mid_dim_3,out_dim_3,mid_dim_5,out_dim_5,pool):
super(inception_module,self).__init__()
self.conv_1 = conv_1(in_dim,out_dim_1)
self.conv_1_3 = conv_1_3(in_dim,mid_dim_3,out_dim_3)
self.conv_1_5 = conv_1_5(in_dim,mid_dim_5,out_dim_5)
self.max_3_1 = max_3_1(in_dim,pool)
def forward(self,x):
out_1 = self.conv_1(x)
out_2 = self.conv_1_3(x)
out_3 = self.conv_1_5(x)
out_4 = self.max_3_1(x)
output = torch.cat([out_1,out_2,out_3,out_4],1)
return output
3) GoogLeNet¶
In [0]:
# Ç¥¿Í ºñ±³ÇÏ¸é¼ º¼ ¼ö ÀÖµµ·Ï ±¸ÇöÇß½À´Ï´Ù.
class GoogLeNet(nn.Module):
def __init__(self, base_dim, num_classes=2):
super(GoogLeNet, self).__init__()
self.num_classes=num_classes
self.layer_1 = nn.Sequential(
nn.Conv2d(3,base_dim,7,2,3),
nn.MaxPool2d(3,2,1),
nn.Conv2d(base_dim,base_dim*3,3,1,1),
nn.MaxPool2d(3,2,1),
)
self.layer_2 = nn.Sequential(
inception_module(base_dim*3,64,96,128,16,32,32),
inception_module(base_dim*4,128,128,192,32,96,64),
nn.MaxPool2d(3,2,1),
)
self.layer_3 = nn.Sequential(
inception_module(480,192,96,208,16,48,64),
inception_module(512,160,112,224,24,64,64),
inception_module(512,128,128,256,24,64,64),
inception_module(512,112,144,288,32,64,64),
inception_module(528,256,160,320,32,128,128),
nn.MaxPool2d(3,2,1),
)
self.layer_4 = nn.Sequential(
inception_module(832,256,160,320,32,128,128),
inception_module(832,384,192,384,48,128,128),
nn.AvgPool2d(7,1),
)
self.layer_5 = nn.Dropout2d(0.4)
self.fc_layer = nn.Linear(1024,self.num_classes)
def forward(self, x):
out = self.layer_1(x)
out = self.layer_2(out)
out = self.layer_3(out)
out = self.layer_4(out)
out = self.layer_5(out)
out = out.view(batch_size,-1)
out = self.fc_layer(out)
return out
4. Optimizer & Loss¶
In [14]:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
model = GoogLeNet(base_dim=64)
for i in model.named_children():
print(i)
model = GoogLeNet(base_dim=64).to(device)
loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),lr=learning_rate)
5. Train¶
In [15]:
for i in range(num_epoch):
for j,[image,label] in enumerate(train_loader):
x = image.to(device)
y_= label.to(device)
optimizer.zero_grad()
output = model.forward(x)
loss = loss_func(output,y_)
loss.backward()
optimizer.step()
if i % 10 ==0:
print(loss)
In [0]: