[따로 명시하지 않으면 모든 Accuracy는 Top-5 Accuracy를 의미함]

cifar100_AlexNet1

→ 원래 AlexNet의 채널 수와 FCL레이어의 노드 수는 같게 유지하고 이미지의 크기의 차이를 고려하여 맥스 풀링 제거 및 커널 사이즈를 맞게 줄임

class AlexNet1(nn.Module):
    def __init__(self):
        super().__init__()
        # dimension equation = (image_size + 2*padding - kernel_size) / stride + 1
        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=7, stride=3, padding=1),
            nn.Tanh(),
            # (32 + 2*1 - 7) / 3 + 1 = 10
            nn.Conv2d(96, 256, kernel_size=4),
            nn.Tanh(),
            # (10 - 4) / 1 + 1 = 7
            nn.Conv2d(256, 384, kernel_size=2),
            nn.Tanh(),
            # (7 - 2) / 1 + 1 = 6
            nn.Conv2d(384, 384, kernel_size=2),
            nn.Tanh(),
            # (6 - 1) / 1 + 1 = 5
            nn.Conv2d(384, 256, kernel_size=2),
            nn.Tanh(),
            # (5 - 1) / 1 + 1 = 4
        )

        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(256 * 4 * 4, 4096),
            nn.Tanh(),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.Tanh(),
            nn.Linear(4096, 100),
        )

    def forward(self, x):
        x = self.feature_extractor(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

결과: 마지막 에폭에서 Test Accuracy: 49%, Validation Accuracy: 53% 를 찍으며 성장 가능성을 보여줌

cifar100_AlexNet2

→ 성능 비교를 위해서 전에 cifar10 데이터셋에 사용했을 때 Top1 Accuracy 가 67% 나왔던 모델을 사용

class AlexNet2(nn.Module):
    def __init__(self):
        super().__init__()
        # dimension equation = (image_size + 2*padding - kernel_size) / stride + 1
        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=4, stride=2),nn.ReLU(),
            # (32-4)/2+1 = 15
            nn.MaxPool2d(kernel_size=3, stride=2),
            # (15-3)/2+1 = 7
            nn.Conv2d(32, 128, kernel_size=5, padding=2),nn.ReLU(),
            # (7+2*2-5)/1 + 1 = 7
            nn.MaxPool2d(kernel_size=2, stride=1),
            # (7-2)/1+1 = 6
            nn.Conv2d(128, 196, kernel_size=3, padding=1),nn.ReLU(),
            # (6+2*1-3)/1+1 = 6
            nn.Conv2d(196, 196, kernel_size=3, padding=1),nn.ReLU(),
            # (6+2*1-3)/1+1 = 6
            nn.Conv2d(196, 128, kernel_size=3, padding=1),nn.ReLU(),
            # (6+2*1-3)/1+1 = 6
        )

        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(),
            nn.Linear(2048, 100),
        )

    def forward(self, x):
        x = self.feature_extractor(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

→ 처음에 제대로 훈련이 안되는가 싶더니 갑자기 잘 학습하기 시작함 (local minimum에 빠졌다가 나온것일까?)

→ 추가로 훈련시키는 모듈을 만들어서 50 epoch 더 훈련시켜봄

(아래 그림에서 epoch은 0이 아니라 50에서 시작하는걸로 알고 있으면 됨)

→ Test Accuracy: 63.8% Max at 88 Epoch