[카테고리:] 머신러닝/딥러닝

이미지에 대한 Classification 및 Detection, Segmentation에 대한 신경망 모델을 구성하는 레이어 중 Convolution 관련 레이어의 결과값에 대한 시각화에 대한 내용입니다. 딥러닝 라이브러리 중 PyTorch로 예제를 작성했으며, CNN 모델 중 가장 이해하기 쉬운 VGG를 대상으로 하였습니다.

먼저 필요한 패키지와 미리 학습된 VGG 모델을 불러와 그 레이어 구성을 출력해 봅니다.

import matplotlib.pyplot as plt
from torchvision import transforms
from torchvision import models
from PIL import Image

vgg = models.vgg16(pretrained=True).cuda()
print(vgg)

결과는 다음과 같습니다.

위의 특징(Feature)를 추출하는 레이어 중 0번째 레이어의 출력결과를 시각화 합니다. PyTorch는 특정 레이어의 입력 데이터와 그 연산의 결과를 특정 함수로, 연산이 완료되면 전달해 호출해 줍니다. 아래는 이에 대한 클래스입니다.

class LayerResult:
    def __init__(self, payers, layer_index):
        self.hook = payers[layer_index].register_forward_hook(self.hook_fn)
    
    def hook_fn(self, module, input, output):
        self.features = output.cpu().data.numpy()
    
    def unregister_forward_hook(self):
        self.hook.remove()

LayerResult은 레이어의 연산 결과를 검사할 레이어를 특정하는 인자를 생성자의 인자값으로 갖습니다. 해당 레이어의 register_forward_hook 함수를 호출하여 그 결과를 얻어올 함수를 등록합니다. 등록된 함수에서 연산 결과를 시각화하기 위한 데이터 구조로 변환하게 됩니다. 이 클래스를 사용하는 코드는 다음과 같습니다.

result = LayerResult(vgg.features, 0)

img = Image.open('./images/cat.jpg')
img = transforms.ToTensor()(img).unsqueeze(0)
vgg(img.cuda())

activations = result.features

위의 코드의 마지막 라인에서 언급된 activations에 특정 레이어의 결과값이 담겨 있습니다. 이제 이 결과를 출력하는 코드는 다음과 같습니다.

fig, axes = plt.subplots(8,8)
for row in range(8):
    for column in range(8):
        axis = axes[row][column]
        axis.get_xaxis().set_ticks([])
        axis.get_yaxis().set_ticks([])
        axis.imshow(activations[0][row*8+column])

plt.show()

결과 이미지가 총 64인데, 이는 앞서 VGG의 구성 레이어를 살펴보면, 첫번째 레이어의 출력 채널수가 64개이기 때문입니다. 결과는 다음과 같습니다.

추가로 특정 레이어의 가중치값 역시 시각화가 가능합니다. 아래의 코드가 그 예입니다.

import matplotlib.pyplot as plt
from torchvision import transforms
from torchvision import models
from PIL import Image

vgg = models.vgg16(pretrained=True).cuda()

print(vgg.state_dict().keys())
weights = vgg.state_dict()['features.0.weight'].cpu()

fig, axes = plt.subplots(8,8)
for row in range(8):
    for column in range(8):
        axis = axes[row][column]
        axis.get_xaxis().set_ticks([])
        axis.get_yaxis().set_ticks([])
        axis.imshow(weights[row*8+column])

plt.show()

9번 코드에서 가중치를 가지는 레이어의 ID를 출력해 주는데, 그 결과는 다음과 같습니다.

위의 레이어 ID로 가중치값을 가져올 레이어를 특정할 수 있는데요. 최종적으로 위의 코드는 다음과 같이 가중치를 시각화해 줍니다.

1. 가중치 감소(Weight Decay)를 통한 가중치 정형화(Weight Regularization)

손실함수에 어떤 제약 조건을 적용해 오버피팅을 최소화하는 방법으로 L1 정형화와 L2 정형화가 있습니다. 오버피팅은 특정 가중치값이 커질수록 발생할 가능성이 높아지므로 이를 해소하기 위해 특정값을 손실함수에 더해주는 것이 정형화 중 가중치 감소(Weight Decay)이며, 더해주는 특정값을 결정하는 것이 L1 정형화와 L2 정형화입니다. 파이토치에서 이 Weight Decay는 다음 코드처럼 적용할 수 있습니다.

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=0.1)

결과적으로 weight_decay의 값이 커질수록 가중치 값이 작어지게 되고, 오버피팅 현상을 해소할 수 있지만, weight_decay 값을 너무 크게 하면 언더피팅 현상이 발생하므로 적당한 값을 사용해야 합니다.

2. 데이터 증강(Data Augmentation)

훈련 데이터를 알고리즘에 의해 그 수를 늘리는 방법으로, 오버피팅 해소는 물론 훈련 및 테스트 데이터에 대한 정확도를 높일 수 있는 방법입니다. 다음 코드의 예처럼 데이터셋에 대한 transform 인자에 지정하여 적용할 수 있습니다.

mnist_train = dset.MNIST(
    './', 
    train=True, 
    transform = transforms.Compose([
        transforms.Resize(34),                        # 원래 28x28인 이미지를 34x34로 늘립니다.
        transforms.CenterCrop(28),                    # 중앙 28x28를 뽑아냅니다.
        transforms.RandomHorizontalFlip(),            # 랜덤하게 좌우반전 합니다.
        transforms.Lambda(lambda x: x.rotate(90)),    # 람다함수를 이용해 90도 회전해줍니다.
        transforms.ToTensor(),                        # 이미지를 텐서로 변형합니다.
    ]),
    target_transform=None,
    download=True
)

3. 가중치 초기화(Weight Initialization)

신경망이 깊어질 수록 각 신경망의 가중치값들의 분포가 한쪽으로 쏠리거나, 특정 값 부분으로 심하게 모일 수 있는 현상이 발생합니다. 이런 현상이 발생하면 기울기 소실(Gradient Vanishing)이 발생할 수 있고, 신경망의 표현력에 제한이 생겨 신경망을 깊게 구성하는 의미가 사라집니다. 이를 위해 학습하기 전에 가중치를 적당하게 초기하는 것이 필요합니다. 아래의 코드는 파이토치에서 흔히하게 가중치를 초기하는 코드의 예입니다.

class aDNN(nn.Module):
    def __init__(self):
        super(aDNN,self).__init__()
        self.layer = nn.Sequential(
            # ...
        )             
        
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                '''
                m.weight.data.normal_(0.0, 0.1)     # 가중치를 평균 0, 편차 0.1로 초기화
                m.bias.data.fill_(0)                # 편차를 0으로 초기화
                '''

                '''
                init.xavier_normal(m.weight.data)   # Xavier Initialization
                m.bias.data.fill_(0)                # 편차를 0으로 초기화 
                '''

                '''                
                init.kaiming_normal_(m.weight.data) # Kaming He Initialization
                m.bias.data.fill_(0)                # 편차를 0으로 초기화 
                '''
            elif isinstance(m, nn.Linear):
                # 위의 코드와 유사함

Xavier 초기화는 활성화함수가 Sigmoid나 Tanh일때 적당하며, Kaming He 초기화는 활성화 함수가 ReLU일때 적당합니다.

4. 학습률 스케쥴러(Learning Rate Scheduler)

학습이 진행되면서 학습률을 그 상황에 맞게 가변적으로 적당하게 변경될 수 있다면 더 낮은 손실값을 얻을 수 있습니다. 이를 위해 학습률을 스케쥴이 필요합니다. 이와 관련된 코드는 다음과 같습니다.

# 학습률 스케줄러는 옵티마이져를 통해 적용된다.
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 지정한 스텝 단위로 학습률에 감마를 곱해 학습률을 감소시키는 방식
scheduler = lr_scheduler.StepLR(optimizer, step_size=1, gamma= 0.99)       

# 지정한 스텝 지점(예시에서는 10,20,40)마다 학습률에 감마를 곱해줘서 감소시키는 방식
scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[10,20,40], gamma= 0.1)  

# 매 epoch마다 학습률에 감마를 곱해줌으로써 감소시키는 방식
scheduler = lr_scheduler.ExponentialLR(optimizer, gamma= 0.99)                             

# 원하는 에폭마다, 이전 학습률 대비 변경폭에 따라 학습률을 감소시켜주는 방식
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,threshold=1,patience=1,mode='min')

위의 스케줄러를 학습에 적용할때 사용방법은 나뉘는데, StepLR, MultiStepLR, ExponentialLR의 경우는 아래 코드를 참고하기 바랍니다.

for i in range(num_epoch):
    scheduler.step() # !!

    optimizer.zero_grad()
    output = model.forward( .. )
    loss = loss( .. )
    loss.backward()
    optimizer.step()

ReduceLRONPlateau의 경우는 아래 코드를 참고하기 바랍니다.

for i in range(num_epoch):
    optimizer.zero_grad()
    output = model.forward( .. )
    loss = loss( .. )
    loss.backward()
    optimizer.step()
    
    scheduler.step(loss) # !!  

5. 학습 데이터의 정규화(Data Normalization)

입력되는 데이터에 대해서 공간상 분포를 정규화시켜주게 되면, 더 높은 정확도를 얻을 수 있게 됩니다. 정규화의 방법은 전체 데이터에 대한 평균과 표준편차를 이용하는데, 데이터에 대해서 평균을 빼고 표준편차로 나눠줍니다. 이를 위한 코드의 예는 아래와 같습니다.

mnist_train = dset.MNIST(
    "./", 
    train=True, 
    transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=(0.1307,), std=(0.3081,))
    ]),
    download=True
)

mnist_test = dset.MNIST(
    "./", 
    train=False, 
    transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=(0.1307,), std=(0.3081,))
    ]),
    download=True)

데이터에 대한 평균 및 표준편차를 얻는 것은 아래의 글을 참고하기 바랍니다.

이미지 Dataset에 대한 평균과 표준편차 구하기

6. 다양한 경사하강법(Gradient Descent Variants)

최소의 손실값을 찾기 위해 손실함수의 미분으로 구한 기울기를 따라 이동하게 되는데, 이동하는 방식에 대한 선택에 대한 것입니다. SGD 방식, Adam 방식 등이 존재하는데 그중 Adam에 대한 파이토치의 코드는 다음과 같습니다.

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

SGD와 Adam 이외에도 Momentum 방식과 AdaGrad 방식의 있으며, Adam이 Momentum 방식과 AdaGrad 방식의 장점을 혼합한 것입니다.

7. 배치 정규화(Batch Normalization)

각 신경망의 활성화 값 분포가 적당히 퍼지도록 개선하여 원할한 학습이 진행되도록 돕는 기법입니다. 학습속도가 빨라지고, 앞서 언급한 가중치 초기값 설정에 신경쓸 필요가 없게 됩니다. 또하는 오버피팅을 억제하게 되어 가중치 감소 기법이나 드롭아웃 기법의 필요성이 감소합니다. 이 배치 정규화는 배치 단위로 입력되는 데이터의 연산 결과를 다시 결과의 평균과 분선이 1이 되도록 재가공합니다. 그리고 또 다시 특정 값을 곱하고 또 다른 특정값을 더하는 간단한 Scaling 및 Shifting 처리가 이루어집니다. Scaling 및 Shifting 처리를 위한 2개의 값은 학습을 통해 산출됩니다.

아래의 코드는 배치 정규화에 대한 예제 코드입니다.

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.layer = nn.Sequential(
            nn.Conv2d(1, 16, 3, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.Conv2d(16, 32, 3,padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),           
            nn.Conv2d(32, 64, 3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)        
        )
        self.fc_layer = nn.Sequential(
            nn.Linear(64*7*7, 128),
            nn.BatchNorm1d(128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.BatchNorm1d(64),
            nn.ReLU(),            
            nn.Linear(64, 10),
        )       

    def forward(self,x):
        out = self.layer(x)
        out = out.view(batch_size, -1)
        out = self.fc_layer(out)
        return out

학습이 끝나고 평가 시에는 반드시 아래의 코드 호출이 선행되어야 합니다.

model.eval()

8. 드롭아웃(Drop Out)

이 기법이 적용되면 훈련 데이터에 대한 정확도가 떨어지지만 오버피팅을 억제하기 위한 기법입니다. 즉, 특정 확률로 신경망의 뉴런을 비활성화시켜 연산에서 제외시키는 방식입니다. 드롭아웃에 대한 코드 예는 다음과 같습니다.

layer = nn.Sequential(
     nn.Conv2d(1,16,3,padding=1),
     nn.ReLU(),
    nn.Dropout2d(0.2),
    nn.Conv2d(16,32,3,padding=1),
    nn.ReLU(),
    nn.Dropout2d(0.2),
    nn.MaxPool2d(2,2),
    nn.Conv2d(32,64,3,padding=1),
    nn.ReLU(),
    nn.Dropout2d(0.2),
    nn.MaxPool2d(2,2)
)

학습이 끝나고 평가 시에는 반드시 아래의 코드 호출이 선행되어야 합니다.

model.eval()

0~9까지의 손글씨 숫자 데이터인 MNIST을 대상으로 99% 이상의 분류 정확도에 대한 모델 테스트에 대한 글입니다. 이와 유사한 글이 2개 있었는데, 첫번째는 퍼셉트론 방식이고 두번째는 DNN 방식입니다. 아래는 MNIST 데이터셋을 DNN 방식으로 분류한 글입니다.

Model 확장과 가중치값 변경을 통한 예측 정확도 향상

위의 글과는 다르게 이 글은 CNN 방식으로 분류 정확도를 개선했습니다. MNIST 분류에 대한 정확도 순위를 보면 약 40개여의 순위가 존재합니다. 다행인건 이 글의 모델이 이 순위의 상단에 위치한다는 것입니다.

파이토치를 사용했으며, 해당 코드를 대략적으로 살펴보면 다음과 같습니다. 늘 그렇듯이 필요한 패키지를 포함합니다.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dset
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.optim import lr_scheduler

배치 크기와 학습률, 에폭단위의 반복할 학습수를 먼저 지정합니다. 손실값에 큰 영향을 주는 하이퍼 파라메터입니다.

batch_size = 100
learning_rate = 0.001
num_epoch = 20

학습과 테스트를 위한 MNSIT 데이터를 로딩합니다.

mnist_train = dset.MNIST("./", train=True, 
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=(0.1307,), std=(0.3081,))
    ]),
    target_transform=None,
    download=True)

mnist_test = dset.MNIST("./", train=False, 
    transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=(0.1307,), std=(0.3081,))
    ]), target_transform=None, download=True)

train_loader = DataLoader(mnist_train, batch_size=batch_size, shuffle=True, drop_last=True)
test_loader = DataLoader(mnist_test, batch_size=batch_size, shuffle=False, drop_last=True)

중요한 점은 데이터에 대한 정규화가 적용됩니다. 정규화 방식은 전체 데이터에 대한 평균과 표준편차를 사용했습니다. 이 표준과 표준편차를 구하는 방식은 아래글을 참고하기 바랍니다.

이미지 Dataset에 대한 평균과 표준편차 구하기

다음은 신경망입니다.

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.layer = nn.Sequential(
            nn.Conv2d(1, 16, 3, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.Conv2d(16, 32, 3,padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),           
            nn.Conv2d(32, 64, 3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)        
        )
        self.fc_layer = nn.Sequential(
            nn.Linear(64*7*7, 128),
            nn.BatchNorm1d(128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.BatchNorm1d(64),
            nn.ReLU(),            
            nn.Linear(64, 10),
        )       

    def forward(self,x):
        out = self.layer(x)
        out = out.view(batch_size, -1)
        out = self.fc_layer(out)
        return out

중요한 부분은 Convolution Layer와 Affine Layer에 배치정규화가 반영되어 있다는 점입니다. 물론 신경망 구성 레이어와 각 레이어의 뉴런수도 중요한 하이퍼파라메터입니다.

학습 코드입니다. 미분값 계산을 통해 얻어진 경사도 방향으로의 하강 방식은 Adam 방식을 사용했고, 학습률을 고정하지 않고 ReduceLROnPlateau 클래스를 사용하여 손실값의 감소 경향에 따라 변경하도록 하였습니다.

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

model = CNN().to(device)
loss_func = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,threshold=0.1, patience=1, mode='min')    

for i in range(1, num_epoch+1):
    for _,[image,label] in enumerate(train_loader):
        x = image.to(device)
        y_= label.to(device)
        
        optimizer.zero_grad()
        output = model.forward(x)
        loss = loss_func(output, y_)
        loss.backward()
        optimizer.step()

    scheduler.step(loss)      
    print('Epoch: {}, Loss: {}, LR: {}'.format(i, loss.item(), scheduler.optimizer.state_dict()['param_groups'][0]['lr']))

학습 데이터를 통해 학습된 모델을 테스트 데이터를 통해 정확도를 얻는 코드는 다음과 같습니다.

correct = 0
total = 0

model.eval()
with torch.no_grad():
  for image,label in test_loader:
      x = image.to(device)
      y_= label.to(device)

      output = model.forward(x)
      _,output_index = torch.max(output, 1)

      total += label.size(0)
      correct += (output_index == y_).sum().float()

  print("Accuracy of Test Data: {}%".format(100.0*correct/total))

실제 실행해 보면, 정확도가 99.5을 넘기는 것을 볼 수 있었습니다. 아래는 그 중 하나의 출력 결과입니다.