[Paper Review] VGGNet Code 구현 (By PyTorch)

논문을 계속 읽어야지 읽어야지 생각하다가.. 용기를 내어서 한번 읽어본 내용을 코드로 구현해 보겠습니다.

VGGNet Review

논문 리뷰한 내용은 아래 링크에 달아놓겠습니다!

[Paper Review] VGGnet Review

---

VGGNet Architecture 

그러면 한번 VGGNet을 코드로 한번 구현을 하보겠습니다. - D열의 모델(VGG16)을 구현해보았습니다.

• image input - 224 x 224 RGB
• Convolution Stride - 1 pixel로 고정
• 3 x 3 Convolution 연산 x 2 (Channel 64)
• maxpooling - 2 x 2 pixel 적용, Stride = 2
• 3 x 3 Convolution 연산 x 2 (Channel 128)
• maxpooling - 2 x 2 pixel 적용, Stride = 2
• 3 x 3 Convolution 연산 x 3 (Channel 256)
• maxpooling - 2 x 2 pixel 적용, Stride = 2
• 3 x 3 Convolution 연산 x 3 (Channel 512)
• maxpooling - 2 x 2 pixel 적용, Stride = 2
• 3 x 3 Convolution 연산 x 3 (Channel 512)
• maxpooling - 2 x 2 pixel 적용, Stride = 2
• FC(Fully-Connected Layer) - 4096, ReLU
• FC(Fully-Connected Layer) - 4096, ReLU
• FC(Fully-Connected Layer) - 1000, SoftMax

여기서 filter를 3 x 3으로 사용하는 이유는? 깊이가 깊어지고, 비선형성이 증가해 이로운 점이 많다는점... (요약하면 그렇습니다)

---

VGG16 구현 필요 내용

VGG16을 구현하기 위해서 필요한 부분은 아래에 함꼐 정의를 해보겠습니다.

VGG16을 구현하기 위해서는 네트워크 아키텍처를 정의하고 모델을 컴파일한 후 훈련 및 평가를 위한 절차를 설정해야 합니다.

1. 데이터 준비

데이터를 훈련, 검증, 테스트 세트로 나누고, 전처리를 통해 모델에 입력할 형태로 준비합니다.

2. 모델 아키텍처 정의

• 입력 레이어: 입력 이미지의 크기 (예: 224x224x3)
• 컨볼루션 레이어: 여러 개의 컨볼루션 레이어 (3x3 필터)
• 풀링 레이어: 주로 최대 풀링 레이어 (2x2 풀링)
• 완전 연결 레이어(FC): 일반적으로 2~3개의 완전 연결 레이어
• 출력 레이어: Softmax 활성화 함수가 있는 출력 레이어 (예: 클래스 수만큼의 뉴런)

3. 모델 컴파일

• 손실 함수: 분류 문제에서는 보통 categorical_crossentropy를 사용합니다.
• 옵티마이저: 예를 들어, Adam, RMSprop, SGD 등이 있습니다.
• 평가 지표: 정확도(accuracy) 등의 평가 지표를 설정합니다.

4. 모델 훈련

훈련 데이터와 함께 모델을 훈련시킵니다. 여기에는 배치 크기, 에포크 수 등의 하이퍼파라미터 설정이 포함됩니다.

5. 모델 평가 및 예측

훈련된 모델을 사용하여 새로운 데이터에 대한 예측을 수행하고, 검증 및 테스트 데이터에서 모델의 성능을 평가합니다.

---

VGG16 구현 By PyTorch

그러면 한번 PyTorch로 구현해 보겠습니다.

라이브러리 및 데이터 로드

실제 논문에서 코드를 보면 데이터셋 클래스 1000개를 사용합니다. 다만 모델 코드를 로컬에서 돌리는 관계로 데이터셋이 10개인

CIFAR-10 데이터셋을 사용하였습니다.

CIFAR-10 and CIFAR-100 datasets

 

한번 필요한 라이브러리 및 데이터셋을 로드해서 전처리 하는 과정을 수행해 보겠습니다.

import torch
import torch.nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 데이터셋 전처리
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# CIFAR-10 Dataset download & load
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

 

Input된 Image Dataset의 Size를 224 x 224로 지정한 이유는, 논문에서 image input - 224 x 224 RGB 이므로 이미지 사이즈 크기를 지정해주어서 넣어줘야 합니다.

 

# 데이터 확인
index = 1  # 확인할 데이터 인덱스
image, label = trainset[index]  # 이미지와 레이블 분리

# 이미지를 시각화하기 위해 numpy 배열로 변환
image_np = image.numpy().transpose((1, 2, 0))  # (C, H, W) -> (H, W, C)

# 이미지 시각화
plt.imshow(image_np)

32 x 32 이미지의 사이즈를 224 x 224로 늘려서 흐리게 보입니다..

 

---

VGG16 Model Code

아래는 모델 코드입니다.

import torch.nn as nn

class VGG16(nn.Module):
  def __init__(self):
    super(VGG16, self).__init__()
    
    self.features = nn.Sequential(
        # Block 1 (2개 3x3 Convolution, 64 filter)
        nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1), # Input: (3, 224, 224) -> Output: (64, 224, 224)
        nn.ReLU(inplace=True),
        nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(kernel_size=2, stride=2), # Max pooling (2x2) with stride 2 -> Output: (64, 112, 112)

        # Block 2 (2개 3x3 Convolution, 128 filter)
        nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), # Input (64, 112, 112) -> Output (128, 112, 112)
        nn.ReLU(inplace=True),
        nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(kernel_size=2, stride=2), # Max pooling (2x2) with stride 2 -> Output (128, 56, 56)

        # Block 3 (3개 3x3 Convolution, 256 filter)
        nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), # Input (128, 56, 56) -> Output (256, 56, 56)
        nn.ReLU(inplace=True),
        nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
        nn.ReLU(inplace=True),
        nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
        nn.MaxPool2d(kernel_size=2, stride=2), # Max pooling (2x2) with stride 2 -> Output (256, 28, 28)

        # Block 4 (3개 3x3 Convolution, 512 filter)
        nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1), # Input (256, 28, 28) -> Output (512, 28, 28)
        nn.ReLU(inplace=True),
        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
        nn.ReLU(inplace=True),
        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
        nn.MaxPool2d(kernel_size=2, stride=2), # Max pooling (2x2) with stride 2 -> Output (512, 14, 14)

        # Block 5 (3개 3x3 Convolution, 512 filter)
        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), # Input (512, 14, 14) -> Output (512, 14, 14)
        nn.ReLU(inplace=True),
        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
        nn.ReLU(inplace=True),
        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
        nn.MaxPool2d(kernel_size=2, stride=2), # Max pooling (2x2) with stride 2 -> Output (512, 7, 7)
        )
    
    self.classifier = nn.Sequential(
        nn.Flatten(),
        nn.Linear(512 * 7 * 7, 4096), # First FC Layer (4096)
        nn.ReLU(inplace=True),
        nn.Linear(4096, 4096), # Second FC Layer (4096)
        nn.ReLU(inplace=True),
        nn.Linear(4096, 10), # Third FC Layer (1000) -> 원래 논문대로 라면 1000개의 데이터셋이 있어야 하지만, 사용한 데이터셋이 클래스가 10개이므로 10으로 지정
    )

  def forward(self, x):
    x = self.features(x)
    x = self.classifier(x)
    return x

model = VGG16()
print(model)

VGG16(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (16): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (17): ReLU(inplace=True)
    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (19): ReLU(inplace=True)
    (20): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (21): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (22): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (23): ReLU(inplace=True)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (classifier): Sequential(
    (0): Flatten(start_dim=1, end_dim=-1)
    (1): Linear(in_features=25088, out_features=4096, bias=True)
    (2): ReLU(inplace=True)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Linear(in_features=4096, out_features=10, bias=True)
  )
)

 

 

마지막 FC Layer에 SoftMax가 적용이 됩니다. 근데 추가를 안한 이유는 nn.CrossEntropyLoss와 같은 손실 함수에 Softmax가 포함되어 있으므로, 모델의 최종 레이어에서는 직접 적용할 필요가 없습니다.

모델의 출력은 logits 형태로, 손실 함수가 내부적으로 SoftMax를 적용하여 클래스 확률을 계산합니다.

 

---

Model Compile

Loss Function (손실함수), Optimizer 등을 정의합니다.

# 모델 초기화
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = VGG16().to(device)

# 손실 함수와 옵티마이저 정의
criterion = nn.CrossEntropyLoss()  # 교차 엔트로피 손실 함수
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)  # SGD 옵티마이저

---

Model 훈련, 평가 함수 정의

훈련 데이터와 함께 모델을 훈련시킵니다. 여기에는 배치 크기, 에포크 수 등의 하이퍼파라미터 설정이 포함됩니다.

def train(model, device, train_loader, optimizer, epoch):
    model.train()  # 모델을 학습 모드로 설정
    train_loss = 0
    correct = 0
    total = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)  # 데이터를 장치로 이동
        optimizer.zero_grad()  # 이전 기울기 초기화
        output = model(data)  # 모델 예측
        loss = criterion(output, target)  # 손실 계산
        loss.backward()  # 역전파를 통해 기울기 계산
        optimizer.step()  # 가중치 업데이트

        train_loss += loss.item()  # 배치 손실 합산

        # 학습 정확도 계산
        pred = output.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()
        total += target.size(0)

        if batch_idx % 100 == 0:  # 100번째 배치마다 로그 출력
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}')

    train_loss /= len(train_loader)  # 평균 손실 계산
    train_accuracy = 100. * correct / total
    return train_loss, train_accuracy

# 모델 평가 함수 정의
def test(model, device, test_loader):
    model.eval()  # 모델을 평가 모드로 설정
    test_loss = 0
    correct = 0
    with torch.no_grad():  # 평가 시에는 기울기를 계산하지 않음
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item()  # 손실 합산
            pred = output.argmax(dim=1, keepdim=True)  # 가장 높은 확률을 가진 클래스 예측
            correct += pred.eq(target.view_as(pred)).sum().item()  # 맞춘 개수 합산

    test_loss /= len(test_loader.dataset)
    test_accuracy = 100. * correct / len(test_loader.dataset)
    print(f'\nTest set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} '
          f'({test_accuracy:.0f}%)\n')
    return test_loss, test_accuracy

 

Epoch (학습 횟수)는 맘같아선 논문에 나온것 처럼 50번을 하고 싶었지만.. 시간이슈 때문에 10번만 학습을 시켜보겠습니다.

 

epochs = 10
train_losses, test_losses, train_accuracies, test_accuracies = [], [], [], []

# 모델 학습
for epoch in range(1, epochs + 1):
    train_loss, train_accuracy = train(model, device, trainloader, optimizer, epoch)
    test_loss, test_accuracy = test(model, device, testloader)
    train_losses.append(train_loss)
    test_losses.append(test_loss)
    train_accuracies.append(train_accuracy)
    test_accuracies.append(test_accuracy)

---

모델 평가 및 예측

모델의 전반적인 Architecture & 얼마나 Over, Underfitting이 되었는지 그래프를 그려 한번 확인해 보겠습니다.

from torchsummary import summary
summary(model, input_size=(3, 224, 224))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
              ReLU-2         [-1, 64, 224, 224]               0
            Conv2d-3         [-1, 64, 224, 224]          36,928
              ReLU-4         [-1, 64, 224, 224]               0
         MaxPool2d-5         [-1, 64, 112, 112]               0
            Conv2d-6        [-1, 128, 112, 112]          73,856
              ReLU-7        [-1, 128, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         147,584
              ReLU-9        [-1, 128, 112, 112]               0
        MaxPool2d-10          [-1, 128, 56, 56]               0
           Conv2d-11          [-1, 256, 56, 56]         295,168
             ReLU-12          [-1, 256, 56, 56]               0
           Conv2d-13          [-1, 256, 56, 56]         590,080
             ReLU-14          [-1, 256, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         590,080
        MaxPool2d-16          [-1, 256, 28, 28]               0
           Conv2d-17          [-1, 512, 28, 28]       1,180,160
             ReLU-18          [-1, 512, 28, 28]               0
           Conv2d-19          [-1, 512, 28, 28]       2,359,808
             ReLU-20          [-1, 512, 28, 28]               0
           Conv2d-21          [-1, 512, 28, 28]       2,359,808
        MaxPool2d-22          [-1, 512, 14, 14]               0
           Conv2d-23          [-1, 512, 14, 14]       2,359,808
             ReLU-24          [-1, 512, 14, 14]               0
           Conv2d-25          [-1, 512, 14, 14]       2,359,808
             ReLU-26          [-1, 512, 14, 14]               0
           Conv2d-27          [-1, 512, 14, 14]       2,359,808
        MaxPool2d-28            [-1, 512, 7, 7]               0
          Flatten-29                [-1, 25088]               0
           Linear-30                 [-1, 4096]     102,764,544
             ReLU-31                 [-1, 4096]               0
           Linear-32                 [-1, 4096]      16,781,312
             ReLU-33                 [-1, 4096]               0
           Linear-34                   [-1, 10]          40,970
================================================================
Total params: 134,301,514
Trainable params: 134,301,514
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 208.76
Params size (MB): 512.32
Estimated Total Size (MB): 721.65
----------------------------------------------------------------

 

# 정확도 그래프 그리기
plt.plot(range(1, epochs + 1), train_accuracies, label='Train Accuracy')
plt.plot(range(1, epochs + 1), test_accuracies, label='Test Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.title('Train and Test Accuracy over Epochs')
plt.legend()
plt.show()

실행했을때 그래프를 보면, Overfitting이 난다는 점을 볼수 있습니다.

다만 이러한 점은 Batchsize를 64, epoch를 10정도 주어, 너무 많이 학습이 되어서 그렇게 볼수 있다고 생각합니다..