[파이토치로 시작하는 딥러닝 기초]07_MLE, Overfitting, Regularization, Learning Rate

Maximum Likelihood Estimation(MLE, 최대우도추정법)

observation을 가장 잘 설명하는 theta를 찾아내는 과정
우리가 관찰한 데이터를 가장 잘 설명하는 어떤 확률 분포의 함수의 파라미터를 찾아내는 과정

 

Optimization via Gradient Descent

𝜃←𝜃−𝛼∇𝜃𝐿(𝑥;𝜃)

 

Overfitting

• 과도한 훈련으로 모델이 훈련셋에만 최적화 되어있을 떄
• 훈련셋과 테스트셋을 나누어서 학습할 때 오버피팅을 낮출 수 있다.

오버피팅을 해결하는 방법, Regularization

• Early Stopping : Validation Loss가 더이상 낮아지지 않을 때 학습을 멈추는 것
• Reducing Network Size : neural network의 사이즈를 줄이는 것
• Weight Decay : neural network weight 파라미터의 크기를 제한하는 것
• Dropout
• Batch Normalization

DNN 학습할 때 기본 접근 방법 : Basic Approach to Train DNN

1. NN의 아키텍쳐를 만든다.(Make a neural network architecture)
2. 모델이 오버피팅 됏는지 확인한다. (train and check that model is over-fitted)
   • if it is not, increase the model size(deeper and wider)
     • 오버피팅이 아닐 경우, 모델을 더 깊고 정교하게 만든다. 
   • if it is, add regularization, such as drop-out, batch normalization
     • 오버피팅인경우, regularization을 실행한다. 
3. step 2부터 반복.(repeat from step-2)

실습

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

torch.manual_seed(1)

x_train = torch.FloatTensor([[1, 2, 1],
                            [1, 3, 2],
                            [1, 3, 4],
                            [1, 5, 5],
                            [1, 7, 5],
                            [1, 2, 5],
                            [1, 6, 6],
                            [1, 7, 7]
                            ])
y_train = torch.LongTensor([2, 2, 2, 1, 1, 1, 0, 0])

x_test = torch.FloatTensor([[2, 1, 1], [3, 1,2], [3, 3, 4]])
y_test = torch.LongTensor([2, 2, 2])

# 모델정의
class SoftmaxClassifierModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(3, 3)
    def forward(self, x):
        return self.linear(x)

# 모델 선언
model = SoftmaxClassifierModel()

# optimizer 설정
optimizer = optim.SGD(model.parameters(), lr = 0.1)

def train(model, optimizer, x_train, y_train):
    nb_epochs = 20
    for epoch in range(nb_epochs):
        
        #H(x) 계산
        prediction = model(x_train)
        
        # cost 계산
        cost = F.cross_entropy(prediction, y_train)
        
        # cost로 H(x) 계선
        optimizer.zero_grad()
        cost.backward()
        optimizer.step()
        
        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
            epoch, nb_epochs, cost.item()
        ))

def test(model, optimizer, x_test, y_test):
    prediction = model(x_test)
    predicted_class = prediction.max(1)[1]
    correct_count = (predicted_class == y_test).sum().item()
    cost = F.cross_entropy(prediction, y_test)
    
    print('Accuracy: {}% Cost: {: .6f}'.format(
        correct_count / len(y_test) * 100, cost.item()
    ))

train(model, optimizer, x_train, y_train)

>>>
Epoch    0/20 Cost: 2.203667
Epoch    1/20 Cost: 1.199645
Epoch    2/20 Cost: 1.142985
Epoch    3/20 Cost: 1.117769
...
Epoch   16/20 Cost: 1.007872
Epoch   17/20 Cost: 1.001586
Epoch   18/20 Cost: 0.995419
Epoch   19/20 Cost: 0.989365

test(model, optimizer, x_test, y_test)

Learning Rate

learning rate이 너무 크면 diverge 하면서 cost가 점점 늘어난다. (overshooting)

model = SoftmaxClassifierModel()
optimizer = optim.SGD(model.parameters(), lr = 1e5)
train(model, optimizer, x_train, y_train)

>>>
Epoch    0/20 Cost: 1.280268
Epoch    1/20 Cost: 976950.750000
Epoch    2/20 Cost: 1279135.125000
...
Epoch   17/20 Cost: 940566.562500
Epoch   18/20 Cost: 931638.250000
Epoch   19/20 Cost: 1971322.625000

learning rate가 너무 작으면 cost가 거의 줄지 않는다.

model = SoftmaxClassifierModel()
optimizer = optim.SGD(model.parameters(), lr = 1e-10)
train(model, optimizer, x_train, y_train)

>>>
Epoch    0/20 Cost: 3.187324
Epoch    1/20 Cost: 3.187324
Epoch    2/20 Cost: 3.187324
...
Epoch   17/20 Cost: 3.187324
Epoch   18/20 Cost: 3.187324
Epoch   19/20 Cost: 3.187324

적절한 숫자로 시작해 발산하면 작게, cost가 줄어들지 않으면 크게 조정하자

Data Preprocessing

x_train = torch.FloatTensor([[73, 80, 75],
                            [93, 88, 93],
                            [89, 91, 90],
                            [96, 98, 100],
                            [73, 66, 70]])
y_train = torch.FloatTensor([[152], [185], [180], [196], [142]])

standardization => 정규분포화

$${x'_{j} = \frac{x_{j} - \mu_{j}}{\sigma_{j}}}$$

 

mu = x_train.mean(dim = 0)
sigma =x_train.std(dim = 0)
norm_x_train = (x_train - mu) / sigma

print(norm_x_train)

>>>
tensor([[-1.0674, -0.3758, -0.8398],
        [ 0.7418,  0.2778,  0.5863],
        [ 0.3799,  0.5229,  0.3486],
        [ 1.0132,  1.0948,  1.1409],
        [-1.0674, -1.5197, -1.2360]])

출처 : 

www.boostcourse.org/ai214/lecture/42291

파이토치로 시작하는 딥러닝 기초