[Pytorch] Pytorch Tutorial - ANN

Artificial Neural Network (ANN)

• Logistic Regression보다 non-linear function 개수를 늘려서 더 복잡한 모델을 만들 수 있다.
• 복잡한 모델은 복잡한 현상을 더 정확히 예측할 수 있다.
• 3층의 hidden layer를 추가하고 ReLU, Tanh, ELU activation function을 사용한다.
• 자세한 내용은 아래 링크에서 ANN 파트를 확인하면 된다.

Pytorch Tutorial for Deep Learning Lovers | Kaggle

Pytorch Tutorial for Deep Learning Lovers

 

import torch
import torch.nn as nn
from torch.autograd import Variable

class ANNModel(nn.Module):

    def __init__(self, input_dim, hidden_dim, output_dim):
        super(ANNModel, self).__init__() # 부모 클래스의 변수값들을 상속받아온다.

        # Linear & Non-linear function 1 : 784 -> 150
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.relu1 = nn.ReLU()

        # Linear & Non-linear function 2 : 150 -> 150
        self.fc2 = nn.Linear(hidden_dim, hidden_dim)
        self.tanh2 = nn.Tanh()

        # Linear & Non-linear function 3 : 150 -> 150
        self.fc3 = nn.Linear(hidden_dim, hidden_dim)
        self.elu3 = nn.ELU()

        # Linear function 4: 150 -> 10
        self.fc4 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # 1층
        out = self.fc1(x)
        out = self.relu1(out)

        # 2층
        out = self.fc2(out)
        out = self.tanh2(out)

        # 3층
        out = self.fc3(out)
        out = self.elu3(out)

        # read out
        out = self.fc4(out)
        return out

ANNModel Class를 선언했다. 3층인 hidden layer를 가지며 마지막에 차원 수를 10으로 줄여주는 read out 작업을 한다.

forward 함수는 input 값 x를 뉴럴 네트워크를 통과시켜 output 값 out을 return시킨다.

 

 

Loss function은 Cross Entropy Loss를 사용하고, Optimizer로 Stochastic Gradient Descent를 사용한다.

 

 

중간 파트를 생략하고 ANN을 바로 공부하니 Dataset 준비하는 과정을 생략해버렸다. Dataset은 MNIST를 사용할 것이다.

import pandas as pd
from sklearn.model_selection import train_test_split
from torch.utils.data import DataLoader

# load data
train = pd.read_csv(r"/content/drive/MyDrive/Pytorch Tutorial/train.csv",dtype = np.float32)

# split data into features(pixels) and labels(numbers from 0 to 9)
targets_numpy = train.label.values
features_numpy = train.loc[:,train.columns != "label"].values/255 # normalization

# train test split
features_train, features_test, targets_train, targets_test = train_test_split(features_numpy,
                                                                             targets_numpy,
                                                                             test_size = 0.2,
                                                                             random_state = 42) 

# create feature and targets tensor for train set
featuresTrain = torch.from_numpy(features_train)
targetsTrain = torch.from_numpy(targets_train).type(torch.LongTensor) # data type is long

# create feature and targets tensor for test set.
featuresTest = torch.from_numpy(features_test)
targetsTest = torch.from_numpy(targets_test).type(torch.LongTensor) # data type is long

# batch_size, epoch and iteration
batch_size = 100
n_iters = 10000
num_epochs = n_iters / (len(features_train) / batch_size)
num_epochs = int(num_epochs)

# Pytorch train and test sets
train = torch.utils.data.TensorDataset(featuresTrain, targetsTrain)
test = torch.utils.data.TensorDataset(featuresTest, targetsTest)

# data loader
train_loader = DataLoader(train, batch_size = batch_size, shuffle = False)
test_loader = DataLoader(test, batch_size = batch_size, shuffle = False)

우선 train.csv를 split해서 train과 test data로 사용했다. csv -> pandas -> numpy -> tensor 형태로 데이터를 변환했다.

그리고 학습을 위해 TensorDataset으로 변환한 후 DataLoader를 이용해 batch size를 지정해주었다.

feature 데이터는 이미지 픽셀로 0 ~ 255 의 값을 가진다. 그러므로 255로 나누어주면 normalization이 된다.

 

 

이제 ANN 모델을 학습시켜보자.

# ANN model training
count = 0
loss_list = []
iteration_list = []
accuracy_list = []

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):

        train = Variable(images.view(-1, 28*28)) # 일렬로 펴줌
        labels = Variable(labels)

        # Clear gradients
        optimizer.zero_grad()

        # Forward propagation
        outputs = model(train)

        # Calculate loss
        loss = error(outputs, labels)

        # Calculate gradients
        loss.backward()

        # Update parameters
        optimizer.step()

        count += 1
        # 50번마다 accuracy 측정
        if count % 50 == 0:
            correct = 0
            total = 0

            for images, labels in test_loader:
                test = Variable(images.view(-1, 28*28))
                outputs = model(test)
                predicted = torch.max(outputs.data, 1)[1] # 최대값의 위치만 가져온다. 위치가 바로 예측값!
                
                total += len(labels)
                correct += (predicted == labels).sum()
            
            accuracy = 100 * correct / float(total)
            loss_list.append(loss.data)
            iteration_list.append(count)
            accuracy_list.append(accuracy)

        # 500번마다 결과 출력
        if count % 500 == 0:
            print(f"Iteration: {count} Loss: {loss.data} Accuracy: {accuracy} %")

Accuracy가 약 96%정도로 잘 학습되었다!!!

 

 

학습과정을 간단히 시각화하면 다음 이미지가 나온다.

---

후기

파이토치를 이용해서 첫번째 뉴럴네트워크를 만들어보았다. 확실히 좋은 프레임워크를 사용하니까 딥러닝 학습이 정말 편하다. 파이토치 사용에 대한 두려움이 있었는데 이제 ANN을 기본기로 삼아 다른 모델들도 응용해서 잘 사용할 수 있을 것 같다. 이제 CNN만 공부하면 2주차 스터디 준비는 끝이다!