Visdom에 관하여 & Loss plot 그리기

모두를 위한 딥러닝 - 파이토치 강의 참고

• visdom을 사용하기 위해서는 서버를 실행시켜줘야 한다.

• jupyter notebook의 경우, New –> Terminal –> 실행된 터미널 창에서 다음의 명령어를 입력한다.

1

>>>python -m visdom.server

• pycharm을 이용한다면 파이참 하단의 terminal을 클릭해 위의 명령어를 입력하면된다.

• 다만, visdom의 기본 포트가 사용중이라면 에러가 발생하는데 이때는 visdom 포트변경 포스트를 확인해 해결할 수 있다.

• 서버가 정상적으로 실행됐다면, visdom 객체를 아래와 같이 생성하고 이를 이용해 text, 이미지, 그래프 등을 나타낼 수 있다.

1
2

import visdom
vis = visdom.Visdom()

• 아래에서 진행하는 예제는 실행된 local서버를 접속해 확인할 수 있다.

• Text 출력하기

  • text를 출력하기 위해서 text()를 사용한다.

    1	vis.text('hello world', env='main')

  • 이때 env='main'은 실행문의 이름을 지정해 추후에 main으로 실행된 모든 창을 한번에 종료할 수 있게 해준다.

• Image 출력하기

  • image 출력은 image()를 사용한다.

  • 랜덤한 이미지를 출력해보자.

    1 2	ex = torch.randn(3, 200, 200) vis.image(ex)

  • 여러장의 이미지를 출력하기 위해서는 images()를 사용한다.

    1	vis.images(torch.Tensor(3,3,28,28))

  • CIFAR10의 이미지를 가져와 출력해보자.

    1 2 3 4

    cifar10 = dsets.CIFAR10(root="cifar10/",train = True, transform=torchvision.transforms.ToTensor(),download=True) data = cifar10.__getitem(0)__ vis.images(data[0], env='main')

  • DataLoader로부터 여러개의 이미지를 출력할 수 있다.

    1 2 3 4 5 6 7 8 9 10 11

    MNIST = dsets.MNIST(root="MNIST_data/",train = True,transform=torchvision.transforms.ToTensor(), download=True) data_loader = torch.utils.data.DataLoader(dataset = MNIST, batch_size = 32, shuffle = False) for num, value in enumerate(data_loader): value = value[0] vis.images(value) break ###>>> batch_size만큼의 이미지가 한번에 출력된다

• Line Plot 그리기

  • line plot은 line()을 사용한다.

  • 임의의 y값을 가지는 그래프를 그려보자.

    1 2 3

    Y_data = torch.randn(5) X_data = torch.Tensor([1,2,3,4,5]) plt = vis.line(Y=Y_data, X=X_data)

  • 위를 통해 plt라는 이름의 그래프가 그려지는 것을 확인할 수 있다. 만약 이때 X 범위를 설정해주지 않았다면 X의 범위는 0과 1사이에서 출력되게 된다.

  • 이미 그려진 line plot을 업데이트도 할 수 있다. 똑같이 line()을 사용한다. 위에서 그린 plt 그래프에 하나의 값을 업데이트 해보자.

    1 2 3 4

    Y_append = torch.randn(1) X_append = torch.Tensor([6]) vis.line(Y=Y_append, X=X_append, win=plt, update='append')

  • 위와같이 업데이트할 plot의 이름을 win에 지정해주고 update='append'로 지정하면 기존의 그래프에 하나의 값이 추가된 것을 확인할 수 있다.

  • 하나의 window에 두개의 line plot을 그릴때도 line()을 사용한다.

    1 2 3 4 5 6

    num = torch.Tensor(list(range(0,10))) num = num.view(-1,1) num = torch.cat((num,num),dim=1) print(num.shape) ###>>> (10,2) plt = vis.line(Y=torch.randn(10,2), X = num)

• Line Plot의 정보 나타내기

  • line plot에 title과 legend를 나타내기 위해서는 dict형태의 입력값을 사용한다.

  • 위에 그린 그래프에 title과 legned를 나타내보자.

    1	plt = vis.line(Y=Y_data, X=X_data, opts=dict(title='test', legend=['1번'], showlegend=True))

  • 두개의 line plot에도 각각의 legend를 나타낼 수 있다.

    1	plt = vis.line(Y=torch.randn(10,2), X=num, optes=dict(title='test', legend=['1번','2번'], showlegend=True))

• 창 닫기

  • env='main'으로 지정한 창을 닫기 위해서 close()를 사용한다.

    1	vis.close(env='main')

• 기본적인 visdom 사용법을 알아보았으며, 이를 이용해 CNN MNIST의 코드를 조금 변형해 loss plot을 그려보자.

  • loss plot을 그리기 위해서 line plot을 업데이트해줄 함수를 만들어주자.

    1 2 3 4 5 6

    def loss_tracker(loss_plot, loss_value, num): ### loss_plot : line plot value ### loss_value : Tensor ### num : Tensor ### return : None vis.line(X=num, Y=loss_value, win=loss_plot, update='append')

  • 그리고 loss를 업데이트해줄 빈 line plot을 하나 만들어준다.

    1	loss_plot = vis.line(Y=torch.Tensor(1).zero_(), opts=dict(title='loss', legend=['loss'], showlegend=True))

  • 이후 모델 생성은 모두 동일하지만, train을 진행할때 위의 함수를 통해 그래프를 업데이트 해주는 부분이 추가된다.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

    total_batch = len(data_loader) model.train() for epoch in range(epochs): avg_cost = 0 for X, Y in data_loader: X = X.to(device) Y = Y.to(device) optimizer.zero_grad() hypothesis = model(X) loss = criterion(hypothesis, Y) loss.backward() optimizer.step() avg_cost += loss / total_batch print('[Epoch: {:>4}] cost = {:>.9}'.format(epoch + 1, avg_cost)) loss_tracker(loss_plot, torch.Tensor([avg_cost]), torch.Tensor([epoch])) ###>>> loss_tracker함수를 통해 그래프를 업데이트 print('learning finished')

  • 학습을 진행하면서 visdom의 line plot이 실시간으로 업데이트되는 모습을 확인할 수 있다.

Full Code

Full Code - Visdom Example
Full Code - Loss tracker

Pytorch MNIST에 CNN모델 만들기

모두를 위한 딥러닝 - 파이토치 강의 참고

• Convolution layer를 활용해서 MNIST이미지를 학습시킬 CNN 모델을 만들어보자.

• 아래 CNN 구조와 비슷한 모델을 설계해본다.

• 

  CNN 모델

• torch.nn.Sequential을 통해 위의 그림에서 나타내는 각 layer와 Fully Connected layer를 표현할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

class CNN(torch.nn.Module):

    def __init__(self):
        super(CNN, self).__init__()
        self.drop_prob = 0.5
		
        self.layer1 = torch.nn.Sequential(
            torch.nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )
        self.layer2 = torch.nn.Sequential(
            torch.nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )
        self.layer3 = torch.nn.Sequential(
            torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )
        self.fc1 = torch.nn.Linear(3*3*128, 625, bias=True)
        torch.nn.init.xavier_uniform_(self.fc1.weight)

        self.layer4 = torch.nn.Sequential(
            self.fc1,
            torch.nn.ReLU(),
            torch.nn.Dropout(p=self.drop_prob)
        )

        self.fc2 = torch.nn.Linear(625, 10, bias=True)
        torch.nn.init.xavier_uniform_(self.fc2.weight)
	
	def forward(self, x):
        output = self.layer1(x)
		# print(output.shape)
        output = self.layer2(output)
		# print(output.shape)
        output = self.layer3(output)
		# print(output.shape)
        output = output.view(output.size(0), -1)
        output = self.layer4(output)
        output = self.fc2(output)
        return output

• Conv2d와 MaxPool2d을 지닌 layer를 통과하면서 output의 shape은 게속 변하게 된다.

• 이러한 과정에서 Fully Connected layer를 지날때는 이전 layer에서 나온 output의 shape를 알아야한다.

• 이때 이전 포스트에서 알아본 공식을 통해 output shape을 계산할 수 있다.

• 또한, forward를 진행하면서 각각의 layer를 통과한 output의 shape를 출력하면서 확인할 수도 있다.

• CNN 모델을 배우기 전에는 선형함수만을 통해 MNIST이미지를 학습했다면 이번 과정에서는 지금까지 배운 Dropout, weight initialization, Convolution layer 등을 사용하는 모델을 만들 수 있었다.

• 학습과 평가는 기존 MNIST 학습 코드와 유사하고, Full Code 링크를 통해 확인할 수 있다.

Full Code

Full Code

Pytorch Convolution layer에 대하여

모두를 위한 딥러닝 - 파이토치 강의 참고

• Convolution layer란 이미지 위에서 filter가 stride값만큼 움직이며 이미지와 filter가 겹쳐지는 부분의 각 원소의 값을 곱하고 모두 더한 값을 출력으로 하는 연산이다.

• 아래와 같은 이미지 위에서 stride가 1인 filter가 움직이며 나타나는 출력을 계산해보자.

• 

  Convolution

1
2
3
4
5
6
7
8
9
10
11
12
13

위의 그림에서 아래와 같은 필터를 사용했을 때 나오는 결과값을 하나 계산해보자

filter = [[1, 0, 1],
		   [0,1, 0],
		   [1, 0, 1]]

3x3필터가 이미지와 처음 겹쳐졌을 때 다음과 같은 연산이 수행된다.

output = (1*1) + (0*1) + (1*1) +
		 (0*0) + (1*1) + (0*1) +
		 (1*0) + (0*0) + (1*1) = 4

따라서, 우측 Convolution Feature의 처음 값이 4로 나타나는 것을 확인할 수 있고, 이후에도 stride가 1이므로, 한칸씩 움직이며 같은 연산을 반복한다.

• zero-padding

  • zero-padding이란 이미지 주변에 패드를 끼우듯 0으로 채워진 테두리를 둘러 inpute size를 키워주는 것이다.

  • zero-padding을 사용하는 이유는 Convolution layer를 지났을 때 이미지의 크기를 보존해주기 위해서다.

  • 위에서 우리는 3x3 의 filter를 사용한 결과, 원래 이미지의 크기가 5x5에서 3x3으로 줄어든 것을 볼 수 있었다.

  • 이와같은 Convolution layer를 반복적으로 지날때 이미지의 크기가 작아져서 정보의 손실이 생기게된다.

  • 하지만, zero-padding을 이용해 원본 이미지의 size를 키워서 Convolution layer를 지나게 한다면, 원본 이미지의 크기를 보존시켜 정보의 손실을 최소화할 수 있게된다.

  • 

    Convolution with zero-padding

  • 위의 그림에서 Input size가 Output에서도 보존되는것을 확인할 수 있다.
    
    
    

• Output size 계산하기

  • Convolution layer를 지나쳤을때 나오는 output size는 input size, filter size, stride, padding에 의해 결정되며, 다음과 같은 공식을 따른다.

    1	output size = ((input size - filter size + (2*padding)) / strid) + 1

  • 위의 이미지를 예시로 계산해보면 다음과 같다.

    1	output size = ((4x4 - 3x3 + (2*1)) / 1) + 1 = (1x1 + 2) + 1 = (3x3)+1 = 4x4

  • input size의 높이와 넓이가 다를때도 동일하게 계산할 수 있다.

  • 이처럼 하나의 Convolution layer를 통과했을 때 나오는 output size를 계산할 수 있고 이를 다음 layer의 입력값으로 활용할 수 있게된다.

• 참고

  • Convolution layer 이미지
  • padding 이미지

Pytorch Batch Normalization에 대하여

모두를 위한 딥러닝 - 파이토치 강의 참고

• overfitting과 gradient vanishing문제를 해결하기 위해 앞서서 ReLU 포스트와 Dropout 포스트를 적었었다.

• 이번 포스트에서는 또 다른 방법인 Batch Normalization방법을 정리하고자 한다.

• Batch Normalization은 모델이 깊어질수록 나타나는 Internal Covariate Shift를 해결하면서 등장했다.

• Internal Covariate Shift란 모델이 깊어질수록 output의 분포가 편향되는 문제를 말합니다.

• 이를 해결하기 위해 Batch마다 output을 Normalization하는 방식이 등장합니다.

• Batch Normalization도 dropout과 똑같이 train()과 eval()을 구분지어서 사용해야 합니다.

• 왜냐하면, Batch Normalization을 통해 평균, 분산과 학습하는 데이터 scale값 감마, shift값 베타를 저장해서 사용하기 때문입니다.

• 따라서, 학습을 위해서는 dropout때와 마찬가지로 train()함수를, 평가를 위해서는 저장된 값을 이용하기 위해 eval()함수를 먼저 작성해야합니다.

• Batch Normalization은 dropout과 다르게 활성화 함수 이전에 적용시킵니다.

• 이를 이용해 Batch Normalization을 사용한 경우와, 사용하지 않은 경우를 비교해 보겠습니다.

• Dropout 포스트때와 유사하지만 Batch Normalization을 다음과 같이 만들어서 두 가지 모델을 정의했습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

linear1 = torch.nn.Linear(784, 32, bias=True)
linear2 = torch.nn.Linear(32, 32, bias=True)
linear3 = torch.nn.Linear(32, 10, bias=True)
relu = torch.nn.ReLU()
bn1 = torch.nn.BatchNorm1d(32)
bn2 = torch.nn.BatchNorm1d(32)

# BatchNorm을 사용하지 않는 모델을 만들기 위한 Linear layer 만들기
nn_linear1 = torch.nn.Linear(784, 32, bias=True)
nn_linear2 = torch.nn.Linear(32, 32, bias=True)
nn_linear3 = torch.nn.Linear(32, 10, bias=True)

# 모델 정의
bn_model = torch.nn.Sequential(linear1, bn1, relu,
                               linear2, bn2, relu,
                               linear3).to(device)
nn_model = torch.nn.Sequential(linear1, relu,
                               linear2, relu,
                               linear3).to(device)

• 이후, 학습을 진행할 때 각 epoch마다 평가를 진행하면서 Loss와 Accuracy를 저장시켜 line plot을 그려 비교해 보겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 학습 & 각epoch 마다 평가
for epoch in range(epochs):
    bn_model.train()
    for X, Y in train_loader:
        X = X.view(-1, 28*28).to(device)
        Y = Y.to(device)
		.
		.
		.
	with torch.no_grad():
		bn_model.eval()

		# train셋을 통한 평가
		bn_loss, nn_loss, bn_Acc, nn_Acc = 0, 0, 0, 0
		for i, (X, Y) in enumerate(train_loader):
			X = X.view(-1, 28 * 28).to(device)
			Y = Y.to(device)
			.
			.
			.
		# test셋을 통한 평가
        bn_loss, nn_loss, bn_Acc, nn_Acc = 0, 0, 0, 0
        for i, (X, Y) in enumerate(test_loader):
            X = X.view(-1, 28 * 28).to(device)
            Y = Y.to(device)
			.
			.
			.

• 이후 train과 validation의 Loss와 Accuracy를 Line Plot으로 그려 확인할 수 있었습니다.

• 

  training Loss

• 

  training Acc

• 

  validation Loss

• 

  validation Acc

• 그림에서도 확인할 수 있듯이 Batch Normalization을 적용했을 때, validation의 Loss가 더 작은것을 확인할 수 있었습니다.

• 데이터 로딩 ~ 이미지 생성까지 생략된 부분은 아래 Full Code를 확인해주세요.

Full Code

Full Code

Pytorch Dropout에 대하여

모두를 위한 딥러닝 - 파이토치 강의 참고

• Dropout은 모델의 layer가 많아질때 생기는 overfitting문제를 해결하기 위해 사용된다.

• overfitting이란 train데이터를 모델이 지나치게 정확히 학습하는 바람에 모델이 test데이터에서는 좋은 결과를 내놓지 못하는 경우이다.

• 

  overfitting

• 위 그림에서 초록색선을 보면 빨간점과 파란점을 완벽하게 분류하는 것을 확인할 수 있다. 이렇게 train 데이터에 지나치게 학습된 경우를 overfitting이라하며, 적절한 학습의 정도를 까만선이 나타내고 있다.

• 이러한 overfitting문제를 해결하기 위해 dropout을 사용하게 된다.

• dropout이란 forward함수를 통해 train데이터가 layer를 지날때 뉴런 일부를 생략하고 학습을 진행하는것이다.

• 

  dropout

• 위의 우측 그림과 같이 layer마다 임의의 뉴런을 생략하고 학습을 진행하는 것을 볼 수 있다.

• 사용자가 정의한 비율만큼의 뉴런을 생략하고 학습을 진행할 때, 매 epoch마다 다른 뉴런들이 꺼졌다가 켜지기를 반복하게 된다.

• 이는 매번 다른 모델을 학습하는것과 유사하기 때문에 Ensemble(앙상블)효과를 기대할 수도 있다.

• dropout을 사용할 때는 non-linear 활성화 함수 다음에 사용하게 된다.

• MNIST 데이터셋을 이용해 활용법을 살펴보자.

• 통과할 linear 와 relu 그리고 dropout을 설정해준다.

1
2
3
4
5
6
7
8

# nn Linear layer / relu / dropout 만들기
linear1 = torch.nn.Linear(784, 512, bias=True)
linear2 = torch.nn.Linear(512, 512, bias=True)
linear3 = torch.nn.Linear(512, 512, bias=True)
linear4 = torch.nn.Linear(512, 512, bias=True)
linear5 = torch.nn.Linear(512, 10, bias=True)
relu = torch.nn.ReLU()
dropout = torch.nn.Dropout(p=drop_prob) # drop_prob = 0.3 in my code

• 이를 이용해 모델을 만들때 선형함수를 통과하고 활성화 함수를 지난 뒤에 dropout을 적용해준다.

1
2
3

model = torch.nn.Sequential(linear1, relu, dropout, linear2, relu, dropout,
                            linear3, relu, dropout, linear4, relu, dropout,
                            linear5).to(device)

• 이렇게 만들어진 모델로 학습과 평가를 똑같이 진행할 수 없다.

• 왜냐하면 학습 이후 평가할 때 dropout이 켜져있다면 모든 weight를 사용하지 않고 output을 내게 되기 때문이다.

• 이렇게 dropout은 학습할때는 사용하고, 평가를 위해서는 사용하지 말아야한다.

• 이를 조절할 수 있는 함수가 train()함수와 eval()함수이다.

• 다음고 같이 train()함수를 통해 dropout을 사용하겠다는 표시를 한 후, 학습을 진행해야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

model.train() # train() 함수를 사용하면 dropout=True로 설정된다.
# 즉 학습할때 사용해야하고 추후 모델을 평가할때는 eval()함수를 꼭 설정해줘야한다.
for epoch in range(epochs):
    avg_loss = 0
    for X, Y in data_loader:
        X = X.view(-1, 28*28).to(device)
        Y = Y.to(device)

        hypothesis = model(X)
        loss = criterion(hypothesis, Y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        avg_loss += loss / total_batch

    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_loss))

print('Learning finished')

• 학습을 마친 후, 랜덤한 하나의 데이터를 통해 결과를 확인해 보고 싶다면 다음과 같이 eval()함수를 통해 dropout을 사용하지 않겠다고 표시한 후 평가를 진행해야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

with torch.no_grad(): # --> 여기에서는(test에서는) gradient를 계산하지 않고 진행한다는 뜻이다.
    model.eval() # --> eval() 함수를 사용하면 dropout=False 로 설정되서 모든 노드를 사용해 모델을 평가하게된다.
    X_test = mnist_test.test_data.view(-1, 28*28).float().to(device)
    Y_test = mnist_test.test_labels.to(device)

    prediction = model(X_test)
    correct_prediction = torch.argmax(prediction, dim=1) == Y_test
    accuracy = correct_prediction.float().mean()
    print('Accuracy:', accuracy.item())

    r = random.randint(0, len(mnist_test) - 1)
    X_single_data = mnist_test.test_data[r:r + 1].view(-1, 28 * 28).float().to(device)
    Y_single_data = mnist_test.test_labels[r:r + 1].to(device)

    print('Label: ', Y_single_data.item())
    single_prediction = model(X_single_data)
    print('Prediction: ', torch.argmax(single_prediction, 1).item())

• 첫째로, dropout은 non-linear 활성화 함수 다음에 사용한다는 점

• 둘째로, 학습과 평가를 위해서는 train()함수와 eval()함수를 반드시 사용해야 된다는 것을 기억해야겠다.

Full Code

Full Code

Pytorch Weight initialization에 대하여

모두를 위한 딥러닝 - 파이토치 강의 참고

• 모델을 학습하기 이전에 weight의 초기값을 설정하는 문제는 모델의 학습에 굉장히 중요한 문제였습니다.

• 초기에 이 문제를 해결하기 위해서 사용했던 방법은 RBM(restricted boltzmann machine)이었습니다.

• RBM은 layer1과 다음 레이어 layer2를 통해 weight1을 학습한 후 w1을 고정한 상태에서 layer2와 layer3를 통해 weight2를 학습하는 과정을 반복하는 방법입니다.

• 

  RBM

• 하지만, 요즘에는 새로운 initialization 방법들이 제안되면서 RBM을 많이 사용하지 않고 있습니다.

• 대표적으로 간단히 initialization할 수 있는 두 가지 방법인 Xavier / He initialization 에 대해 알아보겠습니다.

• Xavier initialization

  • Xavier / He initialization 모두 Normal initialization 방법과 Uniform initialization 방법을 가지고 있으며 모두 간단한 수식을 통해 이루어집니다.

  • Xavier Normal initialization

    $$W\sim N({ 0 }, Var(W))$$ $$Var(W)=\sqrt{\frac { 2 }{ { n }_{ in }+{ n }_{ out } } }$$

  • n_in은 layer의 input수, n_out은 layer의 output수를 뜻합니다.
    
    
    

  • Xavier Uniform initialization

    $$W\sim U(- \sqrt{\frac { 6 }{ { n }_{ in }+{ n }_{ out } } } , \space\space + \sqrt{\frac { 6 }{ { n }_{ in }+{ n }_{ out } } } )$$

  • n_in은 layer의 input수, n_out은 layer의 output수를 뜻합니다.
    
    
    

• He initialization

  • He Normal initialization

    $$W\sim N({ 0 }, Var(W))$$ $$Var(W)=\sqrt{\frac { 2 }{ { n }_{ in } } }$$

  • n_in은 layer의 input수를 뜻합니다.
    
    
    

  • He Uniform initialization

    $$W\sim U(- \sqrt{\frac { 6 }{ { n }_{ in } } } , \space\space + \sqrt{\frac { 6 }{ { n }_{ in } } } )$$

  • n_in은 layer의 input수를 뜻합니다.

• Pytorch에서는 torch.nn.init패키지를 통해서 사용할 수 있습니다.

• ReLU에 관해서 작성한 포스트에서 작성한 코드와 달라진 점은 weight를 초기화해주는 부분뿐입니다.

• 먼저 linear layer를 만들고,

1
2
3
4

linear1 = torch.nn.Linear(784, 256, bias=True)
linear2 = torch.nn.Linear(256, 256, bias=True)
linear3 = torch.nn.Linear(256, 10, bias=True)
relu = torch.nn.ReLU()

• 다음과 같이 xavier_uniform으로 초기화 할 수 있습니다.

1
2
3

torch.nn.init.xavier_uniform_(linear1.weight)
torch.nn.init.xavier_uniform_(linear2.weight)
torch.nn.init.xavier_uniform_(linear3.weight)

• ReLU 포스트의 코드와 다른점은 weight initialization뿐이지만 Accuracy가 상승된것을 확인할 수 있습니다.

Full Code

Full Code

Pytorch ReLU에 대하여

모두를 위한 딥러닝 - 파이토치 강의 참고

• 이전 포스팅에서 두 가지 클래스를 분류하는 모델을 만들때 sigmoid함수를 사용했습니다.

• 하지만, sigmoid함수에는 모델이 깊어질수록 vanishing Gradient문제가 발생하게 됩니다.

• vanishing Gradient란, 역전파를 통해 gradient를 전파받을 때, 0에 근접한 값들이 곱해짐에 따라 앞단으로 갈수록 gradient가 사라지게 되는 문제입니다.

• 이러한 문제가 생기는 이유는 sigmoid 함수 그래프를 통해 확인할 수 있습니다.

• 

  sigmoid 그래프

• sigmoid 그래프의 양 극단으로 갈수록 기울기는 0에 수렴하게 되는것을 볼 수 있고, 이때문에 역전파를 통해 gradient가 곱해질 때마다 그 값 또한 0으로 수렴하게 됩니다.

• 따라서 아래 그림과 같이 역전파가 깊이 전달될수록 gradient가 사라지는 vanishing gradient 문제가 발생하게 됩니다.

• 

  vanishing Gradient

• 이러한 문제를 해결하기 위해 Hinton교수님이 찾아낸 방법이 바로 ReLU 입니다.

• ReLU를 수식으로 나타내면 다음과 같습니다.

1

f(x) = max(0, x)

• 입력값 x가 들어왔을때, 0보다 크다면 자기자신을 그렇지 않다면 0을 되돌려주는것이 바로 ReLU입니다.

• 코드에서 활성화 함수만 sigmoid에서 ReLU로 바꾸면 되기때문에 ReLU를 이용한 MNIST classifier 를 만들어보겠습니다.

1
2
3
4
5

# nn Linear layer 만들기
linear1 = torch.nn.Linear(784, 256, bias=True)
linear2 = torch.nn.Linear(256, 256, bias=True)
linear3 = torch.nn.Linear(256, 10, bias=True)
relu = torch.nn.ReLU()

• Linear layer와 활성화 함수로 사용할 ReLU를 정의해주고, Linear layer의 weight를 normalization 합니다.

1
2
3
4

# Linear layer의 weight를 normalization시켜주기
torch.nn.init.normal_(linear1.weight)
torch.nn.init.normal_(linear2.weight)
torch.nn.init.normal_(linear3.weight)

• 위를 이용해 모델을 정의하고,

1
2
3
4

# 모델 정의
model = torch.nn.Sequential(linear1, relu, linear2, relu, linear3).to(device)
###>>> 왜 linear3다음에는 relu를 하지않는가
###>>> 우리가 사용할 criterion은 CrossEntropyLoss인데 여기에는 마지막에 softmax activation이 포함되어 있기 때문이다.

• loss / optimizer 를 정의합니다.

1
2
3

# loss / optimizer 정의
criterion = torch.nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

• 정한 epoch수만큼 모델을 학습시킵니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

total_batch = len(data_loader)
for epoch in range(epochs):
    avg_loss = 0
    for X, Y in data_loader:
        X = X.view(-1, 28*28).to(device)
        Y = Y.to(device)

        hypothesis = model(X)
        loss = criterion(hypothesis, Y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        avg_loss += loss / total_batch

    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_loss))

• 학습이 끝났다면 테스트 데이터에서 하나를 선택해 예측값과 실제값을 비교해 결과를 확인해봅니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

with torch.no_grad(): # --> 여기에서는(test에서는) gradient를 계산하지 않고 진행한다는 뜻이다.
    X_test = mnist_test.test_data.view(-1, 28*28).float().to(device)
    Y_test = mnist_test.test_labels.to(device)

    prediction = model(X_test)
    correct_prediction = torch.argmax(prediction, dim=1) == Y_test
    accuracy = correct_prediction.float().mean()
    print('Accuracy:', accuracy.item())

    r = random.randint(0, len(mnist_test) - 1)
    X_single_data = mnist_test.test_data[r:r + 1].view(-1, 28 * 28).float().to(device)
    Y_single_data = mnist_test.test_labels[r:r + 1].to(device)

    print('Label: ', Y_single_data.item())
    single_prediction = model(X_single_data)
    print('Prediction: ', torch.argmax(single_prediction, 1).item())

• 하나의 데이터를 통해 예측값과 실제값까지 확인해볼 수 있었습니다.

Full Code

Full Code

Pytorch Softmax Classificaton 을 통한 N개의 이벤트 분류하기

모두를 위한 딥러닝 - 파이토치 강의 참고

• binary classificaton 문제를 해결할 때 sigmoid함수를 사용했습니다.

• 정확히는 F.binary_cross_entropy 안에 sigmoid함수가 같이 녹아있는 형태로 loss함수를 사용했습니다.

• 하지만, 세개 이상의 분류문제를 해결하기 위해서는 sigmoid함수가 아닌 softmax함수를 사용해야 합니다.

• softmax함수는 아래와 같은 식으로 나타낼 수 있습니다.

• 

  softmax

• K개의 입력값을 0~1 사이의 값이 되도록 K개의 SUM으로 나눠주게 됩니다. 따라서 모든 확률의 합은 1이됩니다. 또한 입력값의 순서가 출력값의 순서와 같음을 확인할 수 있습니다.

• 이제 Pytorch를 통해 SoftmaxClassifierModel을 정의해 보았습니다.

1
2
3
4
5
6
7
8
9
10

# 모델 정의
class SoftmaxClassifierModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(16, 7)

    def forward(self, x):
        return self.linear(x)

model = SoftmaxClassifierModel()

• 모델을 정의한 내용을 보면 입력값X에 따른 Linear함수만을 통과하고 Softmax함수를 통과하지 않는것을 볼 수 있습니다.

• 이는 loss함수에서 사용하게 될 F.cross_entropy에 Softmax함수가 포함되어 있기 때문입니다.

• 따라서 정의한 모델에서는 Softmax를 통과하기전의 Linear함수를 통과한 output값을 되돌려줘야 합니다.

• optimizer를 정의하고,

1
2

# optimizer 정의
optimizer = optim.SGD(model.parameters(), lr=0.1)

• 정한 epoch수 만큼 학습하며 loss를 출력해봅니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

epochs = 1000
# 학습
for epoch in range(epochs + 1):

    predict = model(x_train)
    loss = F.cross_entropy(predict, y_train)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print('Epoch {:4d}/{} loss : {:.6f}'.format(
            epoch, epochs, loss.item()
        ))
		
###>>>print
Epoch    0/1000 loss : 1.721660
Epoch  100/1000 loss : 0.462462
.
.
.
Epoch  900/1000 loss : 0.110220
Epoch 1000/1000 loss : 0.100880

• 출력된 loss를 통해 모델이 정상적으로 학습되는것을 확인할 수 있습니다. 이처럼 N개의 이벤트를 분류할 경우는 Softmax함수를 두개의 이벤트를 분류할 경우는 Sigmoid함수를 사용한다는것을 배울 수 있었습니다.

Full Code

Full Code

Pytorch Multi Layer Perceptron(MLP)에 관하여 with code

모두를 위한 딥러닝 - 파이토치 강의 참고

• perceptron은 입력값 x에 대해 weight를 곱하고 bias를 더한 후 activation function을 거쳐서 나온 output을 통해 두가지의 class를 가지는 AND, OR 문제를 해결하기 위해 고안되었습니다.

• AND gate는 다음과 같이 표로 나타낼 수 있습니다.

• 위의 표는 매우 익숙하지만 이를 그래프로 나타내면 다음과 같이도 나타낼 수 있습니다.

• 

  AND gate

• 위의 그래프에서 0과 1을(off와 on)을 선 하나를 통해서 구분할 수 있는 방법은 빨간 점선으로 표시되어 있습니다. 즉, 하나의 선으로 두 가지의 class를 구분할 수 있습니다.

• OR gate도 마찬가지 입니다.

• 위와 같은 OR gate표를 그래프로 나타내면 다음과 같습니다.

• 

  OR gate

• OR gate 그래프에서도 0과 1(off와 on)을 하나의 선으로 구분할 수 있습니다. 즉, AND gate와 마찬가지로 하나의 선으로 두 가지의 class를 구분할 수 있다는 뜻입니다.

• 다시 말해, AND 와 OR gate는 하나의 Layer를 가지는 perceptron으로 구분이 가능했습니다.

• 하지만, XOR gate는 달랐습니다.

• XOR gate를 표로 나타내면 다음과 같습니다.

• 이와같이 입력이 같으면 0을 다르면 1을 되돌려주는 XOR gate를 그래프로 나타내면 다음과 같습니다.

• 

  XOR gate

• 위와 같은 그래프에서 0과 1(off와 on)을 하나의 선으로 구분할 수 없었습니다. 즉, 하나의 perceptron으로는 AND/OR gate 문제는 해결할 수 있었지만 XOR gate 문제를 해결할 수 없었습니다.

• 이렇게 하나의 perceptron으로 해결할 수 없는 문제를 해결하기 위해 등장한것이 Multi Layer Perceptron입니다.

• 다시 한번 위의 그래프를 봤을때, 하나의 선이 아니라 두개의 선으로는 0과 1(off와 on)을 구분할 수 있을까요?

• 답은 YES입니다. 즉, 두개 이상의 perceptron으로는 XOR gate문제를 해결할 수 있었습니다.

• 4개의 Layer를 갖는 모델을 구현해 확인해 보겠습니다.

• 먼저 XOR gate에 해당하는 데이터를 만들고,

1
2
3

# XOR 데이터
X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]]).to(device)
Y = torch.FloatTensor([[0], [1], [1], [0]]).to(device)

• 4개의 layer를 생성해 모델을 정의해줍니다.

1
2
3
4
5
6
7
8
9
10

# 4개의 레이어가 있는 MLP(Multi Layer Perceptron)
linear1 = torch.nn.Linear(2, 10, bias=True)
linear2 = torch.nn.Linear(10, 10, bias=True)
linear3 = torch.nn.Linear(10, 10, bias=True)
linear4 = torch.nn.Linear(10, 1, bias=True)
sigmoid = torch.nn.Sigmoid()

# 모델 정의
model = torch.nn.Sequential(linear1, sigmoid, linear2, sigmoid, linear3, sigmoid,
                            linear4, sigmoid).to(device)

• 이후 loss와 optimizer를 정의해주고,

1
2
3

#  loss / optimizer 정의
criterion = torch.nn.BCELoss().to(device)
optimizer = torch.optim.SGD(model.parameters(), lr=1)

• 모델을 통해 weight와 bias를 학습합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 학습
for epoch in range(10001):
    optimizer.zero_grad()
    hypothesis = model(X)

    loss = criterion(hypothesis, Y)
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print(epoch, loss.item())
#>>> print
0 0.6948983669281006
100 0.6931558847427368
200 0.6931535005569458
.
.
.
9800 0.00016415018762927502
9900 0.00016021561168599874
10000 0.0001565046259202063

• 학습이 끝나면 실제값과 예측값이 잘 맞아 떨어지는지 확인합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 학습 후 실제값과 예측값 비교해보기
with torch.no_grad():
    hypothesis = model(X)
    predict = (hypothesis > 0.5).float()
    accuracy = (predict == Y).float().mean()

    print('Hyptthesis : ', hypothesis.detach().cpu().numpy(),
          '\nCorrect : ',predict.detach().cpu().numpy(),
          '\nAccuracy : ',accuracy.item())
#>>> print
Hyptthesis :  [[1.1168354e-04]
 [9.9982882e-01]
 [9.9984241e-01]
 [1.8533420e-04]] 
Correct :  [[0.]
 [1.]
 [1.]
 [0.]] 
Accuracy :  1.0

• 위의 결과를 통해 Multi Layer Perceptron을 사용하면 XOR gate문제를 해결할 수 있음을 확인했습니다.

• 참고

Full Code

Full Code

Pytorch Logistic regression(Binary Classifier만들기)

모두를 위한 딥러닝 - 파이토치 강의 참고

• 0과 1 두 가지를 분류하기 위한 binary classifier를 만들어 보았습니다.

• binary 분류 문제를 해결하기 위해서는 선형 회구와 같은 실수값이 아닌 확률값을 예측해야 합니다.

• 이를 위해 선형 함수와 sigmoid 함수를 통과하는 BinaryClassifier를 다음과 같이 만듭니다.

1
2
3
4
5
6
7
8
9
10
11

# 모델 정의
class BinaryClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(8, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        return self.sigmoid(self.linear(x))
		
model = BinaryClassifier()

• 학습에 사용할 모델을 만들었으니 사용할 데이터를 불러오고 optimizer를 정의합니다.

1
2
3
4
5
6
7

xy = np.loadtxt('data/data-03-diabetes.csv', delimiter=',', dtype=np.float32)
x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]
x_train = torch.FloatTensor(x_data)
y_train = torch.FloatTensor(y_data)

optimizer = optim.SGD(model.parameters(), lr=1)

• 마지막으로 epoch수 만큼 반복해 학습합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

epochs = 100

for epoch in range(epochs + 1):

    hypothesis = model(x_train)

    loss = F.binary_cross_entropy(hypothesis, y_train)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 10 == 0:
        prediction = (hypothesis >= torch.FloatTensor([0.5])).float()
        correct_prediction = (prediction == y_train).float()
        accuracy = correct_prediction.sum().item() / len(correct_prediction)

        print('Epoch : {:4d}/{} loss : {:6f} Accuracy : {:2.2f}'.format(
            epoch, epochs, loss.item(), accuracy*100
        ))

• Accuracy를 나타내줄때 올바른 예측은 hypothesis(predict) 값이 0.5보다 큰값을 기준으로 사용했습니다.

• binary 문제를 해결하기 위해서는 sigmoid함수를 사용했습니다. 다음 강의때 다시한번 적겠지만 세개 이상의 class를 가지는 분류문제를 해결하기 위해서는 softmax함수를 사용해야 한다는 차이점을 기억해야겠습니다.

Full Code

Full Code