딥러닝(10) - AlexNet

👩‍💻 AlexNet

 

📌📌 CNN 구조 톱아보기 

 

-  3차원 구조

-  너비(width)와 높이(height)뿐만 아니라 깊이(depth)를 갖는다. 

-  이미지는 R/G/B 성분 세 개를 갖기 때문에 시작이 3이지만, 합성곱을 거치면서 특성 맵이 만들어지고 이것에 따라 중간 영상의 깊이가 달라지게 된다. (3에서 더 커질수도 있음)

 

 

🐍 AlexNet의 구조 

- 합성곱층 총 다섯 개 + 완전연결층 세 개

- 맨 마지막 완전연결층은 카테고리 1000개를 분류하기 위해 소프트맥스 활성화 함수를 사용함

- GPU 두 개를 기반으로 한 병렬 구조 이다. 

- 네트워크 입력 : 

 

 

목표하는 코드에 대한 네트워크 설계

 

-  GPU-1에서는 주로 컬러와 상관없는 정보를 추출하기 위한 커널이 학습되고, GPU-2에서는 주로 컬러와 관련된 정보를 추출하기 위한 커널이 학습된다. 

 

 

✍ 라이브러리 호출하기

import torch
import torchvision
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms
from torch.autograd import Variable
from torch import optim
import torch.nn as nn
import torch.nn.functional as F
import os
import cv2
import random
from PIL import Image
from tqdm import tqdm_notebook as tqdm
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

✍ 데이터 전처리하기 

 - 앞에서 설명을 했기 때문에 굳이 설명을 첨부하진 않겠다. 

드 6-23 데이터 전처리

class ImageTransform():
    def __init__(self, resize, mean, std):
        self.data_transform = {
            'train': transforms.Compose([
                transforms.RandomResizedCrop(resize, scale=(0.5,1.0)),
                transforms.RandomHorizontalFlip(),
                transforms.ToTensor(),
                transforms.Normalize(mean, std)
            ]),
            'val': transforms.Compose([
                transforms.Resize(256),
                transforms.CenterCrop(resize),
                transforms.ToTensor(),
                transforms.Normalize(mean, std)
            ])
        }

    def __call__(self, img, phase):
        return self.data_transform[phase](img)

 

✍ 이미지가 위치한 경로에서 데이터를 가져와서 훈련, 검증 ,테스트로 분리하기 

cat_directory = '/cat'
dog_directory = '/dog'


cat_images_filepaths = sorted([os.path.join(cat_directory, f) for f in os.listdir(cat_directory)])
dog_images_filepaths = sorted([os.path.join(dog_directory, f) for f in os.listdir(dog_directory)])
images_filepaths = [*cat_images_filepaths, *dog_images_filepaths]
correct_images_filepaths = [i for i in images_filepaths if cv2.imread(i) is not None]

random.seed(42)
random.shuffle(correct_images_filepaths)
train_images_filepaths = correct_images_filepaths[:400]
val_images_filepaths = correct_images_filepaths[400:-10]
test_images_filepaths = correct_images_filepaths[-10:]
print(len(train_images_filepaths), len(val_images_filepaths), len(test_images_filepaths))

훈련, 검증, 테스트에서 사용할 데이터셋의 이미지 수

 

✍ 커스텀데이터셋을 정의하기

class DogvsCatDataset(Dataset):
    def __init__(self, file_list, transform=None, phase='train'):
        self.file_list = file_list #이미지 데이터가 위치한 파일 경로
        self.transform = transform #이미지 데이터 전처리
        self.phase = phase #self.phase는 ImageTransform()에서 정의한 ‘train’과 ‘val’을 의미
    def __len__(self):
        return len(self.file_list)
        
    def __getitem__self(self, idx):
        img_path = self.file_list[idx] #이미지 데이터의 인덱스를 가져오기
        img = Image.open(img_path)
        img_transformed = self.transform(img, self.phase)
        
        label = img_path.split('/')[-1].split('.')[0] #레이블 값 가져오기
        if label == 'dog':
            label = 1
        elif label == 'cat':
            label = 0
            
        return img_transformed, label  # 전처리가 적용된 이미지와 레이블을 반환함

 

 

✍ 변수 정의하기(평균, 표준편차, 배치사이즈, 이미지 데이터 사이즈)

size = 256 #AlexNet은 깊이가 깊은 네트워크를 사용하므로 이미지 크기가 256이 아니면 풀링층 때문에 크기가 줄어 오류 발생
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
batch_size = 32

 

 

 

 

 

✍ AlexNet 모델 네트워크 정의하기

class AlexNet(nn.Module):
    def __init__(self) -> None:
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True), 
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6)) 
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256*6*6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 512),
            nn.ReLU(inplace=True),
            nn.Linear(512, 2),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

 

 

 

nn.ReLU(inplace=True)의 inplace=True

 

- 연산에 대한 결괏값을 새로운 변수에 저장하는 것이 아닌 기존 데이터를 대체하는 것을 의미

-  기존 값을 연산 결괏값으로 대체함으로써 기존 값들을 무시함

 

 

풀링층 

 

nn.AvgPool2d

 

- (N, C, Hin, Win) 크기의 입력을 (N, C, Hout, Wout) 크기로 출력하는 것

 

- Hout, Wout 계산하기

 

AdaptiveAvgPool2d

 

- 풀링 작업이 끝날 때 필요한 출력 크기를 정의