[모두를 위한 딥러닝 시즌2] Lab-09-3 Dropout
[모두를 위한 딥러닝 시즌2] Lab-09-3 Dropout
Overfitting
목표 : 주어진 데이터에 대해 fitting 된 regression을 학습
- Undorfitting
- 선형으로 fitting
- 데이터를 잘 표현하지 못함 (학습이 덜 되었음)
- 저차원의 모델 사용
- 곡선으로 fitting
- 선형보다 복잡한 방법
- 데이터를 일반적으로 잘 표현함
- Overfitting
- 학습 데이터에 과적합되어 있음
- 고차원의 모델 사원 (복잡한 학습을 통해 나타남)
문제점
Overfitting이 학습률은 더 높게 나오지만, Train 데이터와 Test 데이터는 일치하지 않음
Test data 결과는 일반적인 학습 모델이 성능이 더 좋음
초록 선 = 일반 학습 모델, 노란 선 = Overfitting된 모델
- 해결법
- 더 많은 데이터를 사용
- features 감소시키기(불필요한)
- Regularization(정규화)
- Droupout
Dropout
- 학습을 진행하며 Neural Net의 각 Layer에 존재하는 Node를 설정 값 $p$ 에 따라 무작위로 On/Off 하면서 학습하는 방법
- Drouout Layer에서 Mask에 따라, 값이 전달되기 전에 해당 Layer에서 활성화 여부를 결정
- 드롭아웃 마스크는 각 배치(batch) 또는 학습 반복(epoch) 동안 설정 값 $p$ 에 따라서 랜덤하게 결정
- 비활성화된 노드는 해당 학습 단계에서 아예 계산에 참여하지 않는다
- 모델이 특정 노드에 의존하지 않도록 학습을 강제하며, 보다 일반화된 패턴을 학습 가능
- 네트워크 앙상블과 유사한 효과 기대 가능
네트워크 앙상블이란?
여러 신경망(또는 머신러닝 모델)의 예측을 결합하여 성능을 향상시키는 방법
각 모델을 독립적으로 학습시키고, 결과를 평균화하거나 다수결로 조합하여 최종 예측 생성장점: 일반화 성능 향상, 노이즈에 대한 강인성
단점: 계산 비용 증가, 복잡성 증가
적용 방식
$p$ : 노드가 비활성화될 확률
각 노드의 출력을 $p$ 에 따라 스케일 조정
- 드롭아웃으로 인해 감소했던 평균 활성화를 보정
- $출력 값 : 노드 출력 값 × (\frac{1}{1-p})$
학습 과정
$p$ 에 따라 첫번째 Layer의 활성화 여부 설정
Dropout mask = [1, 0, 0, 1, 1]
- 첫번째 Layer에 값이 전달됨
- 첫번째 Layer의 활성화된 노드의 출력값을 스케일 조정
두번째 Layer의 활성화 여부 설정
Dropout mask = [0, 1, 0, 0, 1]
- 두번째 Layer에 값이 전달됨
- 두번째 Layer의 활성화된 노드의 출력값을 스케일 조정
세번째 Layer의 활성화 여부 설정
Dropout mask = [1, 0, 1, 0, 1]
- 세번째 Layer에 값이 전달됨
- 세번째 Layer의 활성화된 노드의 출력값을 스케일 조정
- 최종 Output을 이용하여 역전파 계산 수행 후 반복
주의점
- Train Mode와 Eval Mode
- 드롭아웃은 학습 시에만 활성화되고, 테스트 시에는 모든 노드가 활성화되야 함
- 따라서
train모드와eval모드를 적절히 설정하지 않으면 드롭아웃이 제대로 작동하지 않아 성능에 문제가 생길 수 있다
- 확률 설정
- 일반적으로 $p=0.5$가 많이 사용되지만, 입력 레이어의 경우 과도한 정보 손실을 방지하기 위해 $p=0.2∼0.3$로 설정하는 경우가 많다
- 지나치게 높은 드롭아웃 확률은 학습을 어렵게 만들 수 있음
Code : mnist_nn_dropout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
# Lab 10 MNIST and softmax
import torch
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import random
device = 'cuda' if torch.cuda.is_available() else 'cpu'
# for reproducibility
random.seed(777)
torch.manual_seed(777)
if device == 'cuda':
torch.cuda.manual_seed_all(777)
# parameters
learning_rate = 0.001
training_epochs = 15
batch_size = 100
drop_prob = 0.3
# MNIST dataset
mnist_train = dsets.MNIST(root='MNIST_data/',
train=True,
transform=transforms.ToTensor(),
download=True)
mnist_test = dsets.MNIST(root='MNIST_data/',
train=False,
transform=transforms.ToTensor(),
download=True)
# dataset loader
data_loader = torch.utils.data.DataLoader(dataset=mnist_train,
batch_size=batch_size,
shuffle=True,
drop_last=True)
# nn layers
linear1 = torch.nn.Linear(784, 512, bias=True)
linear2 = torch.nn.Linear(512, 512, bias=True)
linear3 = torch.nn.Linear(512, 512, bias=True)
linear4 = torch.nn.Linear(512, 512, bias=True)
linear5 = torch.nn.Linear(512, 10, bias=True)
relu = torch.nn.ReLU()
dropout = torch.nn.Dropout(p=drop_prob) # p = 드롭아웃 설정 확률
# 드롭아웃 적용 시
# linear1의 노드 중 약 30% (512 * 0.3 = 약 154개) 비활성화됨
# linear2의 노드 중 약 30% (512 * 0.3 = 약 154개) 비활성화됨
# ...
# linear5의 노드 중 약 30% (10 * 0.3 = 약 3개) 비활성화됨
# 활성화된 노드의 출력은 1 / (1 - 0.3) = 약 1.43으로 스케일 조정됨
# 출력값 → 드롭아웃 적용(노드 비활성화) → 활성화된 출력 스케일 조정 → 다음 레이어로 전달
# xavier initialization
torch.nn.init.xavier_uniform_(linear1.weight)
torch.nn.init.xavier_uniform_(linear2.weight)
torch.nn.init.xavier_uniform_(linear3.weight)
torch.nn.init.xavier_uniform_(linear4.weight)
torch.nn.init.xavier_uniform_(linear5.weight)
# model
model = torch.nn.Sequential(linear1, relu, dropout,
linear2, relu, dropout,
linear3, relu, dropout,
linear4, relu, dropout,
linear5).to(device)
# define cost/loss & optimizer
criterion = torch.nn.CrossEntropyLoss().to(device) # Softmax is internally computed.
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
total_batch = len(data_loader)
model.train() # set the model to train mode (dropout=True)
for epoch in range(training_epochs):
avg_cost = 0
for X, Y in data_loader:
# reshape input image into [batch_size by 784]
# label is not one-hot encoded
X = X.view(-1, 28 * 28).to(device)
Y = Y.to(device)
optimizer.zero_grad()
hypothesis = model(X)
cost = criterion(hypothesis, Y)
cost.backward()
optimizer.step()
avg_cost += cost / total_batch
print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
print('Learning finished')
# Epoch: 0001 cost = 0.310754508
# Epoch: 0002 cost = 0.142961308
# Epoch: 0003 cost = 0.112800226
# Epoch: 0004 cost = 0.094463229
# Epoch: 0005 cost = 0.081840351
# Epoch: 0006 cost = 0.076464564
# Epoch: 0007 cost = 0.066869169
# Epoch: 0008 cost = 0.063618518
# Epoch: 0009 cost = 0.057887122
# Epoch: 0010 cost = 0.058847982
# Epoch: 0011 cost = 0.055485275
# Epoch: 0012 cost = 0.050396804
# Epoch: 0013 cost = 0.050088402
# Epoch: 0014 cost = 0.046371866
# Epoch: 0015 cost = 0.045032494
# Test model and check accuracy
with torch.no_grad():
model.eval() # set the model to evaluation mode (dropout=False)
# Test the model using test sets
X_test = mnist_test.test_data.view(-1, 28 * 28).float().to(device)
Y_test = mnist_test.test_labels.to(device)
prediction = model(X_test)
correct_prediction = torch.argmax(prediction, 1) == Y_test
accuracy = correct_prediction.float().mean()
print('Accuracy:', accuracy.item())
# Get one and predict
r = random.randint(0, len(mnist_test) - 1)
X_single_data = mnist_test.test_data[r:r + 1].view(-1, 28 * 28).float().to(device)
Y_single_data = mnist_test.test_labels[r:r + 1].to(device)
print('Label: ', Y_single_data.item())
single_prediction = model(X_single_data)
print('Prediction: ', torch.argmax(single_prediction, 1).item())
# Accuracy: 0.9806999564170837
# Label: 8
# Prediction: 8
This post is licensed under CC BY 4.0 by the author.