간단한 Binary Classification 구현 with linear layer

import torch 
import torch.nn as nn 
import torch.optim as optim

각 데이터는 2개의 feature 를 가지며, 클래스는 0 또는 1로 라벨링됩니다.

import numpy as np 

# 데이터셋 생성
np.random.seed(0)
num_data = 1000
x_data = np.random.randn(num_data, 2).astype(np.float32)
print("Shape of X: ",x_data.shape) # (1000,2)
y_data = ((x_data[:, 0] * x_data[:, 0] + x_data[:, 1] * x_data[:, 1]) > 1.5).astype(np.int32) # boolean to int
print("Shape of Y: ",y_data.shape) # (1000,)
print("Y: ", np.unique(y_data))

Shape of X:  (1000, 2)
Shape of Y:  (1000,)
Y:  [0 1]

모델 정의 : 이진 분류 문제이므로 출력층의 뉴런 수는 1로 설정. 2개의 은닉층을 사용하며, 각 은닉층에는 64개의 뉴런을 사용합니다.

class BinaryClassifier(nn.Module):
    def __init__(self):
        super(BinaryClassifier, self).__init__()
        self.layer1 = nn.Linear(2, 64) # 2차원 입력, 64차원 출력
        self.layer2 = nn.Linear(64, 64) # 64차원 입력, 64차원 출력
        self.layer3 = nn.Linear(64, 1) # 64차원 입력, 1차원 출력
        self.sigmoid = nn.Sigmoid()
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        x = self.relu(x)
        x = self.layer3(x)
        x = self.sigmoid(x)
        
        return x
model = BinaryClassifier()

손실 함수와 optimizer 를 정의. 이진 분류 문제이므로 손실 함수는 Binary Cross Entropy Loss 를 사용

Optimizer 로는 Adam optimizer를 사용

criterion = nn.BCELoss() # Binary Cross Entropy Loss
optimizer = optim.SGD(model.parameters(), lr=0.01)

num_epochs = 1000

for epoch in range(num_epochs) : 
    inputs = torch.from_numpy(x_data)
    labels = torch.from_numpy(y_data)
    
    optimizer.zero_grad()
    
    outputs = model(inputs)
    loss = criterion(outputs, labels.float().view(-1, 1)) # loss 계산 # (prediction, label) # BCELoss : 0~1 사이의 값
    loss.backward()
    optimizer.step()
    
    if (epoch + 1) % 50 == 0:
        print('Epoch [%d/%d], Loss: %.4f' %(epoch+1, num_epochs, loss.item()))
        
with torch.no_grad() : 
    inputs = torch.from_numpy(x_data)
    labels = torch.from_numpy(y_data)
    
    outputs = model(inputs)
    predicted = (outputs > 0.5).float()
    
    accuracy = (predicted == labels.float().view(-1, 1)).sum().item() / len(labels)
    print('Accuracy: %.2f' % accuracy)

# output
Epoch [50/1000], Loss: 0.6819
Epoch [100/1000], Loss: 0.6697
Epoch [150/1000], Loss: 0.6577
Epoch [200/1000], Loss: 0.6454
Epoch [250/1000], Loss: 0.6328
Epoch [300/1000], Loss: 0.6198
Epoch [350/1000], Loss: 0.6061
Epoch [400/1000], Loss: 0.5917
Epoch [450/1000], Loss: 0.5764
Epoch [500/1000], Loss: 0.5601
Epoch [550/1000], Loss: 0.5430
Epoch [600/1000], Loss: 0.5250
Epoch [650/1000], Loss: 0.5063
Epoch [700/1000], Loss: 0.4870
Epoch [750/1000], Loss: 0.4673
Epoch [800/1000], Loss: 0.4471
Epoch [850/1000], Loss: 0.4269
Epoch [900/1000], Loss: 0.4069
Epoch [950/1000], Loss: 0.3873
Epoch [1000/1000], Loss: 0.3682
Accuracy: 0.97