dongdong's devlog

일반적으로 하나의 GPU를 사용할 때는 다음과 같은 코드를 사용한다.

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = Net()
model.to(device)

하지만 다수의 GPU를 사용한다면 다음 코드와 같이 nn.DataParallel을 이용한다.

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Net()
if torch.cuda.device_count() > 1:
  model = nn.DataParallel(net)
model.to(device)

 nn.DataParallel을 사용할 경우 배치 크기가 알아서 각 GPU로 분배되는 방식으로 작동하기 때문에 GPU 수 만큼 배치 크기도 늘려 주어야 한다.

데이터를 훈련, 검증, 테스트 세트로 나누는 것은 간단해 보일 수 있지만 데이터가 적을 때는 몇가지 기법을 사용하면 도움이 된다. 대표적인 세 가지 평가 방법인 hold-out validation, K-fold cross-validation, iterated K-fold cross-validation에 대해 알아보자.

1. hold-out validation

데이터의 일정량을 테스트 세트로 떼어 놓는다. 남은 데이터에서 휸련하고 테스트 세트로 평가한다. 정보 누설을 막기 위해 테스트 세트를 사용하여 모델을 튜닝해서는 안된다. 이런 이유로 검증 세트도 따로 떼어 놓아야 한다.

다음 코드는 간단한 구현 예이다.

num_validation_samples = 10000

np.random.shuffle(data) # 데이터를 섞는 것이 일반적으로 좋다.

validation_data = data[:num_validation_samples] # 검증 세트를 만듬.
data = data[num_validation_samples:]

training_data = data[:] # 훈련 세트를 만듬

model = get_model()
model.train(training_data)
validation_score = model.evaluate(validation_data) # 훈련 세트에서 모델을 훈련하고 검증 세트로 평가한다.

# 다시 모델을 튜닝, 다시 훈련, 평가, 다시 튜닝....

model = get_model()
model.train(np.concatenate([training_data, validation_data])) # 하이퍼파라미터 튜닝이 끝나면 테스트 데이터를 제외한 모든 데이터를 사용하여 모델을 다시 훈련.

test_score = model.evaluate(test_data)

이 평가 방법은 단순해서 한 가지 단점이 있다. 데이터가 적을 때는 검증 세트와 테스트 세트의 샘플이 너무 적어 주어진 전체 데이터를 통계적으로 대표하지 못할 수 있다.

2. K-fold cross validation

이 방식에서는 데이터를 동일한 크기를 가진 K개 분할로 나눈다. 각 분할 i에 대해 남은 K-1개의 분할로 모델을 훈련하고 분할 i에서 모델을 평가한다. 최종 점수는 이렇게 얻은 K개의 점수를 평균한다. 이 방법은 모델의 성능이 데이터 분할에 따라 편차가 클 때 도움이 된다. 

다음은 간단한 구현 예이다.

k = 4
num_validation_samples = len(data) // k

np.random.suffle(data)

validation_scores = []
for fold in range(k):
    
    validation_data = data[num_validation_samples * fold:
                            num_validation_samples + (fold + 1)] # 검증 데이터 부분을 선택한다.
    training_data = data[:num_validation_samples * fold] + 
                            data[num_validation_samples * (fold + 1):] # 남은 데이터를 훈련 데이터로 사용한다.
        
    model = get_model() # 훈련되지 않은 새로운 모델을 만든다.
    model.train(training_data)
    validation_score = model.evaluate(validation_data)
    validation_scores.append(validation_score)
    
validation_score = np.average(validation_scores) # 검증 점수 : K개 폴드의 검증 점수 평균

model = get_model()
model.train(data)
test_score = model.evaluate(test_data)

3. iterated K-fold cross-validation

이 방법은 비교적 가용 데이터가 적고 가능한 정확하게 모델을 평가하고자 할 때 사용한다. 캐글 경연에서는 이 방법이 유용하게 사용된다고 한다. 이 방법은 K-fold CV을 여러 번 적용하되 K개의 분할로 나누기 전에 매번 데이터를 무작위로 섞는다. 최종 점수는 모든 K-fold CV을 실행해서 얻은 점수의 평균이 된다. 결국 P x K개의 모델을 훈련하고 평가하므로 비용이 매우 많이 든다.

공식 Documentation

Python List와 마찬가지로 nn.Module을 저장하는 역할을 한다.

예제

list를 nn.ModuleList()로 감싸 주면 된다.

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])

    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)
        return x

nn.Sequential()과의 차이점

• nn.Sequential() : 안에 들어가는 모듈들을 연결해주고, 하나의 뉴럴넷을 정의한다. 즉, 나열된 모듈들의 output shape과 input shape이 일치해야 한다는 것. 
• nn.ModuleList() : 개별적으로 모듈들이 담겨있는 리스트. 모듈들의 연결관계가 정의되지 않는다. 즉, forward 함수에서 ModulList 내의 모듈들을 이용하여 적절한 연결관계를 정의하는 과정이 필수적이다.

참고자료

https://pytorch.org/docs/stable/generated/torch.nn.ModuleList.html

https://dongsarchive.tistory.com/67

Embedding이란 임의의 길이의 실수 벡터로 밀집되게 표현하는 일련의 방법을 의미한다.

Pytorch는 임베딩 벡터를 사용하는 방법이 크게 두 가지 있다. 바로 임베딩 층을 만들어 훈련 데이터로부터 처음부터 임베딩 벡터를 학습하는 방법과 미리 사전에 훈련된 임베딩 벡터들을 가져와 사용하는 방법이다. 전자에 해당하는 방법이 pytorch에서는 nn.Embedding()을 사용하여 구현한다.

공식 Documentation

This module is often used to store word embeddings and retrieve them using indices. The input to the module is a list of indices, and the output is the corresponding word embeddings.

즉, 이 모듈은 단어 임베딩을 저장하고 인덱스를 사용하여 검색하는 데 자주 사용되고, 모듈에 대한 입력은 인덱스 목록이고 출력은 해당 단어 임베딩이라는 뜻이다.

입력 파라미터

torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, 
                   max_norm=None, norm_type=2.0, scale_grad_by_freq=False, 
                   sparse=False, _weight=None, device=None, dtype=None)

• num_embeddings (int) - 임베딩을 위한 사전의 크기
• embedding_dim (int) - 임베딩 벡터의 크기
• padding_idx (int, optional) - 선택적으로 사용하는 인자. 패딩을 위한 토큰의 인덱스를 알려줌.

예제

import torch.nn as nn

# 크기 3의 텐서 10개가 포함된 임베딩 모듈
embedding = nn.Embedding(10, 3)

# 각각 4개의 인덱스로 구성된 2개의 표본 배치
input = torch.LongTensor([[1,2,4,5], [4,3,2,9]])
embedding(input)

tensor([[[-0.4509, -0.8820, -2.2471],
         [ 0.4561, -0.7103,  1.2992],
         [-0.4517,  0.1363, -0.4372],
         [-0.6953,  1.3094, -0.1399]],

        [[-0.4517,  0.1363, -0.4372],
         [-0.1696,  0.2681, -1.6542],
         [ 0.4561, -0.7103,  1.2992],
         [-0.4525, -1.2973,  0.6719]]], grad_fn=<EmbeddingBackward0>)

출처

https://pytorch.org/docs/stable/generated/torch.nn.Embedding.html

여태까지 matplotlib을 사용할 때 크기 조절을 다음과 같이 해왔다. 하지만 이 방법은 매번 그릴 때 마다 크기를 지정해야하기 때문에 불편하다.

plt.figure(figsize=(16, 4))
plt.plot(dt)

matplotlib.pylab의 rcParams 설정을 활용하면 플랏의 기본 값을 설정할 수 있다고 한다.

import matplotlib.pyplot as plt

plt.rcParams['figure.figsize'] = (16,4)
plt.rcParams['lines.linewidth'] = 2
plt.rcParams['lines.color'] = 'b'

예시는 다음과 같다.

plt.rcParams["figure.figsize"] = (10,4)
plt.rcParams['lines.linewidth'] = 4
plt.rcParams['lines.color'] = 'r'
plt.rcParams['axes.grid'] = True

data = [10, 24, 30, 50, 40]
plt.plot(data)
plt.show()