step50. 미니배치를 뽑아주는 DataLoader

📢 본 포스팅은 밑바닥부터 시작하는 딥러닝3을 기반으로 작성하였습니다. 배운 내용을 기록하고, 개인적인 공부를 위해 작성하는 포스팅입니다. 자세한 내용은 교재 구매를 강력 추천드립니다.

 

 

저번 단계에서는 데이터셋 중 일부를 미니배치로 뽑아 학습시켰습니다. 이번 단계에서는 이러한 과정을 DataLoader 클래스로 구현합니다. DataLoader는 미니배치 생성, 데이터셋 섞기 등의 기능을 제공합니다. 우선 파이썬의 반복자에 대해 알고 있어야 합니다.

 

잘 정리된 글을 아래 링크에 첨부하니, 참고 바랍니다.

[Python] 볼 때마다 헷갈리는 Iterable, Iterator, Generator 정리하기

 

파이썬에서는 반복자를 직접 만들 수 있습니다. 아래 코드가 고유한 반복자를 만드는 예시입니다. __iter__라는 특수 메서드를 구현하여 자기 자신을 반환하도록 합니다. 다음 원소 반환은 __next__를 활용합니다.

class MyIterator:
	def __init__(self, max_cnt):
    	self.max_cnt = max_cnt
        self.cnt = 0
    
    def __iter__(self):
    	return self
        
    def __next__(self):
    	if self.cnt == self.max_cnt:
        	raise StopIteration()
        
        self.cnt += 1
        return self.cnt

 

기본 개념을 공부하였으니, 이제는 DataLodaer를 구현해보겠습니다. 초기화 코드에서 인수를 인스턴스 변수로 저장하고, reset 메서드를 호출합니다. reset 메서드에서는 인스턴스 변수의 반복 횟수를 0으로 설정하고, 데이터의 인덱스를 뒤섞을지 결정합니다. __next__ 메서드가 미니배치를 꺼내 ndarray 인스턴스로 변화하는 코드입니다. 지금까지 사용했던 코드와 같으므로 설명은 생략하겠습니다.

import math
import numpy as np


class DataLoader:
    def __init__(self, dataset, batch_size, shuffle=True):
        self.dataset = dataset  # Dataset 인터페이스를 만족하는 인스턴스
        self.batch_size = batch_size
        self.shuffle = shuffle
        self.data_size = len(dataset)
        self.max_iter = math.ceil(self.data_size / batch_size)

        self.reset()
    
    def reset(self):
        self.iteration = 0
        if self.shuffle:
            self.index = np.random.permutation(len(self.dataset))
        else:
            self.index = np.arange(len(self.dataset))
        
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.iteration >= self.max_iter:
            self.reset()
            raise StopIteration
        
        i, batch_size = self.iteration, self.batch_size
        batch_index = self.index[i * batch_size:(i + 1) * batch_size]
        batch = [self.dataset[i] for i in batch_index]
        x = np.array([example[0] for example in batch])
        t = np.array([example[1] for example in batch])

        self.iteration += 1
        return x, t
    
    def next(self):
        return self.__next__()

 

본격적인 학습 이전에 정확도를 평가하는 accuracy 함수를 구현하겠습니다. 인수 y와 t를 받아 정답률을 계산해줍니다. 참고로 아래와 같이 np.ndarray 데이터 타입을 (pred == t.data) 처럼 비교하면 각 원소마다 일치 불일치를 [True True False] 와 같은 방식으로 반환해줍니다. (파이썬의 리스트를 비교하면 리스트 전체 원소가 같은지 다른지 하나의 불리언 타입을 반환합니다.)

def accuracy(y, t):
    y, t = as_variable(y), as_variable(t)

    pred = y.data.argmax(axis=1).reshape(t.shape)
    result = (pred == t.data)
    acc = result.mean()
    return Variable(as_array(acc))

 

이제 스파이렐 데이터셋을 활용하여 학습을 진행합니다. 이번에는 train과 test용을 나누어서 진행합니다. 테스트 시에는 역전파가 필요하지 않으므로 이전에 구현했던 with dezero.no_grad() 를 활용해 자원 소모를 피합니다. 

import dezero
import dezero.functions as F
from dezero import optimizers
from dezero import DataLoader
from dezero.models import MLP


max_epoch = 300
batch_size = 30
hidden_size = 10
lr = 1.0

train_set = dezero.datasets.Spiral(train=True)
test_set = dezero.datasets.Spiral(train=False)
train_loader = DataLoader(train_set, batch_size)
test_loader = DataLoader(test_set, batch_size, shuffle=False)

model = MLP((hidden_size, 3))
optimizer = optimizers.SGD(lr).setup(model)

for epoch in range(max_epoch):
    sum_loss, sum_acc = 0, 0

    for x, t in train_loader:
        y = model(x)
        loss = F.softmax_cross_entropy(y, t)
        acc = F.accuracy(y, t)

        model.cleargrads()
        loss.backward()
        optimizer.update()

        sum_loss += float(loss.data) * len(t)
        sum_acc += float(acc.data) * len(t)
    
    print('epoch: {}'.format(epoch + 1))
    print('train loss: {:.4f}, accuracy: {:.4f}'.format(
    	sum_loss / len(train_set), sum_acc / len(train_set)))

    sum_loss, sum_acc = 0, 0
    with dezero.no_grad():
        for x, t in test_loader:
            y = model(x)
            loss = F.softmax_cross_entropy(y, t)
            acc = F.accuracy(y, t)

            sum_loss += float(loss.data) * len(t)
            sum_acc += float(acc.data) * len(t)

    print('test loss: {:.4f}, accuracy: {:.4f}'.format(
    	sum_loss / len(test_set), sum_acc / len(test_set)))

 

위 코드의 결과를 그래프로 나타내면 epoch이 진행될수록 loss가 낮아지고 정확도가 상승하는 것을 확인할 수 있습니다. 학습이 제대로 이루어지고 있으며, train과 test의 차이가 작으므로 모델이 과대적합 문제도 일으키지 않았습니다. 다음 단계에서는 스파이럴 데이터셋 대신 MNIST 데이터셋을 사용해보겠습니다.