[PyTorch] Lab06 - Softmax Classification

📌 학습 목표

---

• Softmax
• Cross Entropy
• Low-level Implementation
• High-level Implementation

Softmax

i번째 클래스가 정답일 확률 P를 Softmax는 다음과 같이 정의한다.

• $P(class = i) = \frac{e^i}{\sum{e^i}}$

각 $P_i$의 합은 언제나 1이다.

torch에서는 nn.functional.softmax()메서드를 이용한다.

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

torch.manual_seed(1)

x = torch.FloatTensor([1, 2, 3])
hypothesis = F.softmax(x, dim=0)
print(hypothesis)
print(hypothesis.sum())
'''
tensor([0.0900, 0.2447, 0.6652])
tensor(1.)
'''

Cross Entropy

Softmax 에서는 Coss fucntion으로 Cross Entropy 함수를 사용한다.

• Cross Entropy 함수

  y는 실제값, p는 예측값을 의미하고 각 j는 인덱스 값이다.

  즉, $p_j$는 sample data가 j번째 클래스인 확률을 나타낸다.

  k는 클래스 수를 의미한다.

  $cost(W) = -\sum_{j=1}^{k}y_{j}\ log(p_{j})$

cost 함수를 구현할 때 y의 클래스들을 one-hot encoding을 통해 확률값으로 변환한다.

• one-hot encoding은 해당 원소 이외를 전부 0으로 만드는 작업이다.
• 여기서는 scatter_() 를 사용한다.

데이터의 샘플 수가 n개 라면 평균을 취한다.

$cost(W) = -\frac{1}{n} \sum_{i=1}^{n} \sum_{j=1}^{k}y_{j}^{(i)}\ log(p_{j}^{(i)})$

# data & hypothesis
z = torch.rand(3, 5, requires_grad = True)
hypothesis = F.softmax(z, dim = 1)
print(hypothesis)
# true y
y = torch.randint(5, (3, )).long()
print(y)

# one-hot encoding
y_one_hot = torch.zeros_like(hypothesis)
y_one_hot.scatter_(1, y.unsqueeze(1), 1)
cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean()
print(cost)
'''
tensor([[0.2645, 0.1639, 0.1855, 0.2585, 0.1277],
        [0.2430, 0.1624, 0.2322, 0.1930, 0.1694],
        [0.2226, 0.1986, 0.2326, 0.1594, 0.1868]], grad_fn=<SoftmaxBackward>)
tensor([0, 2, 1])
tensor(1.4689, grad_fn=<MeanBackward0>)
'''

Low-level implemetation

Softmax를 low-level로 구현한다.

필요한 모듈들을 임포트한다.

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

torch.manual_seed(1)

훈련 데이터, 레이블을 tesor.FloatTensor로 선언한다.

• x_train은 4개의 feature을 가지고 있고 8개 샘플이다.
• y_train은 3개의 class label을 가지고있다.

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

가중치(W)와 편향(b)을 선언하고, optimizer로 SGD를 사용하고 learning rate는 0.1로 설정한다.

W = torch.zeros((4, 3), requires_grad = True)
b = torch.zeros(1, requires_grad = True)
# opt
optimizer = optim.SGD([W, b], lr=0.1)

F.softmax()와 torch.log()를 이용해 hypothesis와 cost를 정의하고 학습한다.

nb_epochs = 1000
for epoch in range(nb_epochs + 1):
    
    # Cost
    hypothesis = F.softmax(x_train.matmul(W) + b, dim=1) 
    y_one_hot = torch.zeros_like(hypothesis)
    y_one_hot.scatter_(1, y_train.unsqueeze(1), 1)
    cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean()
    
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()
    
    if epoch%100==0:
        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
            epoch, nb_epochs, cost.item()
        ))
'''
Epoch    0/1000 Cost: 1.098612
Epoch  100/1000 Cost: 0.761050
Epoch  200/1000 Cost: 0.689991
Epoch  300/1000 Cost: 0.643229
Epoch  400/1000 Cost: 0.604117
Epoch  500/1000 Cost: 0.568255
Epoch  600/1000 Cost: 0.533922
Epoch  700/1000 Cost: 0.500291
Epoch  800/1000 Cost: 0.466908
Epoch  900/1000 Cost: 0.433507
Epoch 1000/1000 Cost: 0.399962
'''

High-level implemetation

Softmax를 High-level로 구현한다.

필요한 모듈들을 임포트한다.

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

torch.manual_seed(1)

nn.Module을 이용해 구현한다.

nn.Linear()를 사용하는데 여기서 클래스 수는 3개 이므로 output_dim은 3으로 한다.

class SoftmaxClassifierModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
        
    def forward(self, x):
        return self.linear(x)
    
model = SoftmaxClassifierModel()

F.cross_entropy()를 사용하여 비용함수를 구현한다.

F.corss_entropy()는 softmax함수를 포함하고 있다.

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

nb_epochs = 1000
for epoch in range(nb_epochs+1):
    prediction = model.forward(x_train)
    
    cost = F.cross_entropy(prediction, y_train)
    
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    if epoch%100==0:
        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
            epoch, nb_epochs, cost.item()
        ))
'''
Epoch    0/1000 Cost: 1.849513
Epoch  100/1000 Cost: 0.689894
Epoch  200/1000 Cost: 0.609258
Epoch  300/1000 Cost: 0.551218
Epoch  400/1000 Cost: 0.500141
Epoch  500/1000 Cost: 0.451947
Epoch  600/1000 Cost: 0.405051
Epoch  700/1000 Cost: 0.358733
Epoch  800/1000 Cost: 0.312912
Epoch  900/1000 Cost: 0.269521
Epoch 1000/1000 Cost: 0.241922
'''