모델: cifar10_AlexNet.pth

import torch.nn as nn
import torch

class AlexNet(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)/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

훈련 정보:

model = AlexNet()
    EPOCH = 10
    BATCH = 64
    L_RATE = 0.01
    MOMENTUM = 0.5
    transf = tr.Compose([tr.ToTensor(),
                         tr.Normalize((0.4914, 0.4822, 0.4465),(0.2470, 0.2435, 0.2616))
                         ])
    optimizer = optim.SGD(model.parameters(), lr=L_RATE, momentum=MOMENTUM)
    criterion = nn.functional.cross_entropy

결과: 65.02% 정확도

100 epoch 훈련했더니

결과: 73.24% 정확도

15 epoch이 test_loss 가 제일 낮은 부분인듯 하여 15epoch으로 다시 훈련시킴

결과: 69.94% 정확도