파이토치로 간단한 인공신경망 구현하기 (분류)

필요한 라이브러리 임포트

import torch
import numpy as np
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import torch.nn.functional as F

데이터셋 생성

n_dim=2
x_train, y_train = make_blobs(n_samples=50, n_features=n_dim, 
                              centers=[[1,1],[-1,-1],[1,-1],[-1,1]],
                              shuffle=True, cluster_std=0.3)
x_test, y_test = make_blobs(n_samples=20, n_features=n_dim, 
                              centers=[[1,1],[-1,-1],[1,-1],[-1,1]],
                              shuffle=True, cluster_std=0.3)
#make_blobs - 예제용 데이터셋을 만들어주는 함수
#0,1,2,3클러스터로 인덱싱

간단한 분류 0또는 1을 해보겠습니다. 4개 분류를 2개로 줄여 0또는 1로 라벨링합니다. 

#레이블 2개로 줄이기 0,1
def label_map(y_, from_, to_):
  y = np.copy(y_)
  for f in from_:
    y[y_ ==f] = to_
  return y

y_train = label_map(y_train, [0,1],0)
y_train = label_map(y_train, [2,3],1)
y_test = label_map(y_test, [0,1],0)
y_test = label_map(y_test, [2,3],1)

y_train

array([1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0])

잘 변환되었군요

 

x_train= torch.FloatTensor(x_train)
y_train= torch.FloatTensor(y_train)
x_test= torch.FloatTensor(x_test)
y_test= torch.FloatTensor(y_test)
#numpy vector->pytorch tensor

넘파이 벡터를 파이토치 텐서들로 바꾸면 데이터는 준비가 되었습니다. 

인공신경망을 NN클래스로 구현합니다. 

class NN(torch.nn.Module):
  def __init__(self,input_size,hidden_size):
    super(NN,self).__init__()
    #super(): NN클래스는 nn.Module 클래스의 속성들을 가지고 초기화됨
    #input_size -nn에 입력되는 데이터의 차원
    self.input_size = input_size
    self.hidden_size = hidden_size

    self.linear_1= torch.nn.Linear(self.input_size, self.hidden_size)
    self.relu = torch.nn.ReLU()
    self.linear_2= torch.nn.Linear(self.hidden_size,1)
    self.sigmoid = torch.nn.Sigmoid()

  def forward(self, input_tensor):#init에서 정의한 함수를 차례로 수행해요
    linear1 = self.linear_1(input_tensor)
    relu = self.relu(linear1)
    linear2 = self.linear_2(relu)
    output= self.sigmoid(linear2)
    return output

하이퍼파라미터 설정

model= NN(2,5)
lr = 0.01
criterion = torch.nn.BCELoss()#이진교차엔트로피, loss 연산을 위한 함수
epochs=2500

optimizer= torch.optim.SGD(model.parameters(), lr)
#최적화는 확률적 경사하강법(SGD)
#optimizer는 step()함수를 부를때마다 가중치를 학습률만큼 업데이트하기 때문에 model.parameter()로 추출한 모델 내부의 가중치롸 학습률을 입력

학습 없이 테스트해보겠습니다. 

model.eval()
test_loss_before = criterion(model(x_test).squeeze(),y_test)#스뮈즈로 레이블과 모델의 결괏값의 차원을 맞춰줌
print("Before training, test loss is {}".format(test_loss_before.item()))

Before training, test loss is 0.750939667224884

loss 가 0.75, 100번 중에 75번은 틀린다는 말입니다. 이건 분류 모델이 될 수 없습니다!

학습을 시켜야겠습니다. 

for epoch in range(epochs):
  model.train()
  optimizer.zero_grad()#경삿값을 0으로 설정
  train_output = model(x_train)#생성한 모델에 학습데이터를 입력해 결괏값을 계산한다. 
  train_loss = criterion(train_output.squeeze(), y_train)#결괏값의 차원을 레이블의 차원과 같게 하고 오차 계산
  if epoch % 100 ==0:
    print("train loss at {} is {}".format(epoch, train_loss.item()))
  train_loss.backward()#신경망의 핵심인 역전파 수행 - 오차가 줄어듦
  optimizer.step()

train loss at 0 is 0.7390405535697937
train loss at 100 is 0.7161856293678284
train loss at 200 is 0.7002339363098145
train loss at 300 is 0.6866344213485718
train loss at 400 is 0.6734730005264282
train loss at 500 is 0.6594039797782898
train loss at 600 is 0.6435436010360718
train loss at 700 is 0.6267176270484924
train loss at 800 is 0.6092957854270935
train loss at 900 is 0.5918593406677246
train loss at 1000 is 0.5747905969619751
train loss at 1100 is 0.5576883554458618
train loss at 1200 is 0.5419909954071045
train loss at 1300 is 0.5264553427696228
train loss at 1400 is 0.510536789894104
train loss at 1500 is 0.49399593472480774
train loss at 1600 is 0.4769943654537201
train loss at 1700 is 0.45882469415664673
train loss at 1800 is 0.4398338198661804
train loss at 1900 is 0.4197229743003845
train loss at 2000 is 0.3998076319694519
train loss at 2100 is 0.3801983892917633
train loss at 2200 is 0.36158764362335205
train loss at 2300 is 0.34393927454948425
train loss at 2400 is 0.3267700970172882

model.eval()
test_loss_before = criterion(model(x_test).squeeze(),y_test)#스뮈즈로 레이블과 모델의 결괏값의 차원을 맞춰줌
print("test loss is {}".format(test_loss_before.item()))

이제 학습된 모델을 state_dict() 함수 형태로 바꿔준 후 .pt 파일로 저장하겠습니다. state_dict() 함수는 모델 내 가중치들이 {연산이름 : 가중치 텐서와 편향 텐서}와 같은 딕셔너리 형태의 데이터들로 이루어져 있습니다.

torch.save(model.state_dict(), './model.pt')
print('state_dict format of the model: {}'.format(model.state_dict()))

state_dict format of the model: OrderedDict([('linear_1.weight', tensor([[-0.8449,  0.5479],
        [-0.7441, -0.6253],
        [-0.5887, -0.4028],
        [-1.2672, -1.0648],
        [ 0.5069, -0.8319]])), ('linear_1.bias', tensor([-0.1316, -0.1784,  0.8995, -0.3038,  0.2025])), ('linear_2.weight', tensor([[ 0.7081, -0.8817,  0.9360, -1.5587,  0.6440]])), ('linear_2.bias', tensor([-0.2706]))])

 

이 .pt 파일로 새로운 신경망 객체에 이미 학습된가중치를 바로 적용할 수 있습니다.

new_model = NN(2,5)
new_model.load_state_dict(torch.load('./model.pt'))

<All keys matched successfully>

new_model.eval()
print('벡터 [-1,1]이 레이블 1을 가질 확률은 {}'.format(new_model(torch.FloatTensor([-1,1])).item()))

벡터 [-1,1]이 레이블 1을 가질 확률은 0.8373079299926758

 

 

전체 코드 구글 코랩에서 돌려보기 :

https://colab.research.google.com/drive/1fgFpuioEYbD-hVF6kdCG7Ulyn0RXvu1t?usp=sharing