모델: AlexNet1

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, 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
            nn.MaxPool2d(kernel_size=2, stride=1)
            # (6-2)/1+1 = 5
        )

        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 5 * 5, 1024),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(1024, 1024),
            nn.ReLU(),
            nn.Linear(1024, 10),
        )

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

훈련정보:

    epoch = 26 # 시간관계상 짝수 epoch 마다 accuracy를 측정하도록 설계해서 epoch은 웬만하면 짝수로 설정할것
    batch = 256
    criterion = nn.functional.cross_entropy
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

테스트 결과:

→ test_accuracy는 계속해서 늘어나므로 다음에는 epoch을 더 늘려서 해보자

(아니면 26에폭 학습한 모델을 로드해서 더 학습시켜도 될듯)

→

모델: AlexNet2

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=6, stride=2),nn.ReLU(),
            # (32-4)/2+1 = 14
            nn.MaxPool2d(kernel_size=3, stride=2),
            # (14-3)/2+1 = 6
            nn.Conv2d(32, 128, kernel_size=5, padding=2),nn.ReLU(),
            # (6+2*2-5)/1 + 1 = 6

            # max Pool 빠짐

            nn.Conv2d(128, 196, kernel_size=2),nn.ReLU(),
            # (6-2)/1+1 = 5
            nn.Conv2d(196, 196, kernel_size=2),nn.ReLU(),
            # (5-2)/1+1 = 4
            nn.Conv2d(196, 128, kernel_size=2),nn.ReLU(),
            # (4-2)/1+1 = 3

            #max Pool 빠짐
        )

        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 3 * 3, 1024),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(1024, 1024),
            nn.ReLU(),
            nn.Linear(1024, 10),
        )

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

훈련 정보:

    epoch = 40 # 시간관계상 짝수 epoch 마다 accuracy를 측정하도록 설계해서 epoch은 웬만하면 짝수로 설정할것
    batch = 256
    criterion = nn.functional.cross_entropy
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

테스트 결과: