CHAPTER3 파이토치로 구현하는 ANN 2

# 1. 라이브러리 import
import torch
import numpy
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import torch.nn.functional as F

# 2. 학습과 평가에 사용할 데이터셋 만들기
n_dim = 2

# make_blobs() 사용하여
# 각 데이터 한 점이 몇 번째 클러스터에 속해 있는지 알려주는 인덱스 레이블 생성
x_train, y_train = make_blobs(n_samples = 80, 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)

# 0, 1 => 전부 0번 레이블을 갖도록 바꾸기
# 2, 3 => 전부 1번 레이블 갖도록 바꾸기
def label_map(y_, from_, to_):
    y = numpy.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)


# 시각화
def vis_data(x, y = None, c = 'r'):
    if y is None:
        y = [None] * len(x)
    for x_, y_ in zip(x, y):
        if y_ is None:
            plt.plot(x_[0], x_[1], '*', markerfacecolor = 'none',
                    markeredgecolor = c)
        else:
            plt.plot(x_[0], x_[1], c+'o' if y_ == 0 else c+'+')

plt.figure()
vis_data(x_train, y_train, c = 'r')
plt.show()

# 생성한 데이터를 넘파이 벡터에서 파이토치 텐서로 바꿔주기
x_train = torch.FloatTensor(x_train)
x_test = torch.FloatTensor(x_test)
y_train = torch.FloatTensor(y_train)
y_test = torch.FloatTensor(y_test)

# 신경망 모델을 구현.
# 파이토치에서 신경망은 보통 `torch.nn.Module`을 상속 받는 파이썬 클래스로 정의.
class NeuralNet(torch.nn.Module):
    # 생성자
    def __init__(self, input_size, hidden_size):
        super(NeuralNet, self).__init__() # nn.Module 상속받은 걸로 초기화하기

        self.input_size = input_size # 신경망에 입력되는 데이터의 차원
        self.hidden_size = hidden_size # 신경망의 은닉층 크기

        # 입력된 데이터가 인공 신경망 통과하면서 거치는 연산들
        self.linear_1 = torch.nn.Linear(self.input_size, self.hidden_size) # input_size 개를 받아서 hidden_size 개를 은닉층에 출력
        self.relu = torch.nn.ReLU() # 활성화함수로는 relu 를 쓴다
        self.linear_2 = torch.nn.Linear(self.hidden_size, 1) # hidden_size 개를 입력받아서 1개 출력한다
        self.sigmoid = torch.nn.Sigmoid() # 활성화함수로는 sigmoid 쓴다


    # 위에서 만들어 놓은 애들 차례대로 실행하기
    def forward(self, input_tensor):
        # 입력데이터에 [input_size, hidden_size] 크기의 가중치를 행렬곱하고 편향 더해서 [1, hidden_size] 꼴의 텐서 반환.
        linear1 = self.linear_1(input_tensor) # 위에서 정의한 linear_1에 input_tensor 넣음
        relu = self.relu(linear1)
        linear2 = self.linear_2(relu)
        output = self.sigmoid(linear2)
        return output

# 신경망 객체 생성
model = NeuralNet(2, 5) # input_size = 2, hidden_size = 5
lr = 0.03

# 오차 함수
# BCELoss() = 이진 교차 엔트로피
criterion = torch.nn.BCELoss()

epochs = 2000

# 학습에 사용할 최적화 알고리즘으로는 확률적 경사하강법(SGD) 선택
opt = torch.optim.SGD(model.parameters(), lr = lr)

# 모델 성능 평가
model.eval() # 평가 모드로 변경

# 모델의 결괏값과 레이블(y)의 차원 맞춰주기 위해 squueze로 펴줌.
test_loss_before = criterion(model(x_test).squeeze(), y_test)
print(f"Before Training, test loss is {test_loss_before.item()}")

# 학습을 통한 성능 개선

for epoch in range(epochs):
    model.train() # 학습 모드로 변경
    opt.zero_grad() # epoch마다 새로운 경사값 계산해야하기 때문에 zero_grad() 사용해서 경삿값 0으로 설정.

    train_output = model(x_train) # 학습 데이터로 학습
    train_loss = criterion(train_output.squeeze(), y_train) # 결과값과 실제 정답과 비교해서 오차 계산

    # 학습 잘 되고 있는지 확인
    if epoch % 100 == 0:
        print(f"Train loss at {epoch} is {train_loss.item()}")

    # 오차 함수를 가중치로 미분해서 오차가 최소가 되는 방향으로 학습률만큼 이동하도록 하기
    # = 역전파
    train_loss.backward()
    opt.step()

# 학습 완료된 모델 성능 시험
model.eval() # 평가 모드로 변경
test_loss = criterion(torch.squeeze(model(x_test)), y_test)
print(f"After Training, test loss is {test_loss.item()}")

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

# 새 모델 생성해서 학습한 모델 가중치 입력해보기
new_model = NeuralNet(2, 5)
new_model.load_state_dict(torch.load('./model.pt'))

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