[Deep Learning] LeNet / AlexNet / Fine Tuning

LeNet

• 5개의 계층(2개의 Convolution layer, 3개의 Fully Connected layer)
• 6만개의 parameter
• nMB의 MNIST 데이터셋 사용
• 아래 코드에서 보면, 첫번째 layer의 input dimension이 3이다. 초기에는 단일 이미지가 입력이었는데, 색상 이미지(3채널)이미지가 입력으로 들어오는 구조로 수정되었다. 

이미지 출처 : https://d2l.ai/chapter_convolutional-neural-networks/lenet.html

## LeNet은 maxpooling이 아닌 average pooling을 사용한다. 

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()

        self.cn1 = nn.Conv2d(3, 6, 5)
        self.cn2 = nn.Conv2d(6, 16, 5)

        self.fc1 = nn.Linear(5*5*16, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.relu(self.cn1(x))
        x = F.avg_pool2d(x, (2, 2))

        x = F.relu(self.cn2(x))
        x = F.avg_pool2d(x, (2, 2))

        ## 단일 벡터로 평면화
        
        x = x.view(-1, self.flattened_features(x))

        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)

        return x

    def flattened_features(self, x):

        ## 왜 첫번째 차원 제외?
        size = x.size()[1:]
        num_feats = 1 
        for s in size : 
            num_feats *= s 
        return num_feats 
    
lenet = LeNet()
print(lenet)

 

AlexNet

• LeNet 모델의 아키텍처를 증가시켜 만든 후속 모델.
• 8개 layer(5개의 Convolution layer, 3개의 fully connected layer)
• 6천만개의 parameter 사용
• 100GB가 넘는 ImageNet 데이터셋 사용
• SVM과 같은 고전적인 머신러닝 모델보다 훨씬 더 강력한 모델 클래스로 등장
• Overfitting을 막기 위해 data augmentation, drop out 사용
• network를 2개로 나누어 Multi GPU 사용(GPU Parallelizatoin), 수많은 데이터셋을 사용하기엔 하나의 GPU 로는 부족.

이미지 출처 : https://velog.io/@lighthouse97/AlexNet%EC%9D%98-%EC%9D%B4%ED%95%B4

 

class AlexNet(nn.Module) : 
    def __init__(self, number_of_classes):
        super(AlexNet, self).__init__()
        self.convnet = nn.Sequential(

            nn.Conv2d(3, 96, 11, 4, 0),
            nn.ReLU(),
            nn.LocalResponseNorm(size=5, k=2),
            nn.MaxPool2d((3, 3), 2),

            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(),
            nn.LocalResponseNorm(size=5, k=2), 
            nn.MaxPool2d((3, 3), 2), 

            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(), 

            nn.Conv2d(384, 384, 3, 1, 1),
            nn.ReLU(), 

            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d((3, 3), 2)
        )

        self.fcnet = nn.Sequential(

            nn.Dropout(0.5), 
            nn.Linear(6*6*256, 4096), ## 이전에 maxpooling을 했기 대문에 6x6으로 바뀜
            nn.ReLU(), 

            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(), 

            nn.Linear(4096, number_of_classes)
        )
    
    def forward(self, x):
        x = self.convnet(x)
        x = torch.flatten(x, 1)
        x = self.fcnet(x)
        return x

alexnet = AlexNet(1000)
print(alexnet)

 

AlexNet Fine Tuning 작업

model_finetune.classifier[6] = nn.Linear(4096, len(classes))

위와 같은 방법으로 데이터셋에 맞게 아키텍처를 변경한다. wow! 

코드는 아래 링크에 있다. 

https://github.com/Hyunmin-H/DeepLearningStudy/blob/main/CNN%20architecture/AlexNet.ipynb

GitHub - Hyunmin-H/DeepLearningStudy

 

출처 : 실전 ! 파이토치 딥러닝 프로젝트 책