AITech 학습정리-[DAY 11] 딥러닝 기초

 

==========================

학습내용

[AI Math 8강] 베이즈 통계학 맛보기

D 관찰하는 데이터. theta 관찰하는 이벤트, 파라미터, 모수.

posterior 데이터를 관찰을 했을 때 이 파라미터가 성립할 확률. 데이터를 관찰한 후에 측정한 거라.

사전확률은 사건이 일어나기 전에 모델링하고자 하는 사전에 미리 가정, 모델링 하기 전에 사전에 설정하는 것.

P(D) evidence의 확률, 여기선 진짜로 걸렸을 확률

오탐률(False alarm)이 오르면 테스트의 정밀도(Precision)가 떨어진다.

P(theta|D) 질병에 걸렸다고 검진결과가 나왔을 때 진짜로 감염되었을 확률. 질병에 걸렸을 때 걸렸다고 확진판정이 날 확률. 정밀도.

P(theta) 가 한번 계산하면 -> P(thata|D) 로 업데이트 된다고 볼 수 있을 듯.

앞에서 조건부로 어떤 관계가 있는지 예측해보는게 있었지만 그것만으로는 인과관계까지 추론하는건 불가능하다.

R 지능. T 키. R과 T가지고만 하면 키가 클수록 지능이 높게 나옴. 하지만 Z가 나이. 나이의 연관성이 있다. Z의 효과를 제거하지 않으면 가짜 연관성(spurious correlation)이 나온다. 중첩요인을 제거해야 한다.

어떤 전체적인 확률로 퉁치는듯

[DLBasic] 딥러닝 기본 용어 설명 - Historical Review

구현능력, 수학능력, 최근 많은 연구결과들 알기 (논문 읽기)

딥러닝 중요포인트

- 데이터

- 이미지를 라벨로 바꿔주는 모델. 정의.

- loss function. 회귀문제를 풀땐 제곱을 최소화한다. 분류문제. cross entropy

- 이런 loss function을 최소화하는 알고리즘. 

새로운 논문을 볼 때 이 4가지 측면에서 보면 이 논문이 기존 연구에 비해서 어떤 장점이 있고 대비되는 면은 무었인가 알기 쉽다.

Regression Task 는 MSE로, Classification Task는 Ce로, Probabilistic Task는 MLE(=MSE) 로.. 문제를 풀 때 loss function loss가 줄어든다고 해서 항상 원하는 값을 얻는다는 보장이 없음. 절대값을 쓴다던가.. 이걸 왜 쓰는지. 문제를 어떻게 푸는지 아는게 중요

[DLBasic] PyTorch 시작하기

pytorch(그 외 tensorflow도..). 딥러닝 프레임워크

- Numpy 구조를 가지는 Tensor 객체로 array 표현

- 자동미분을 지원하여 DL 연산을 지원

- 다양한 형태의 DL을 지원하는 함수와 모델을 지원함

https://github.com/BoostcampAITech/lecture-note-python-basics-for-ai/blob/main/codes/pytorch/00_utils/colab%20on%20VSCode.md

윈도우는

https://medium.com/swlh/connecting-local-vscode-to-google-colabs-gpu-runtime-bceda3d6cf64

절대경로. \\ 이스케이프 꼭 만들고 .exe

 

Pytorch basics for DL newbies

numpy to tensor

[1]

import numpy as np

n_array = np.arange(10).reshape(2,5)

n_array

array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

[2]

n_array.ndim

n_array.shape

(2, 5)

[3]

import torch

t_array = torch.FloatTensor(n_array)

t_array

tensor([[0., 1., 2., 3., 4.],
        [5., 6., 7., 8., 9.]])

[4]

t_array.ndim

2

[5]

print(t_array.shape)

print(t_array.ndim)

print(t_array.size())

 

torch.Size([2, 5]) 2 torch.Size([2, 5])

[6]

t_array[1:]

tensor([[5., 6., 7., 8., 9.]])

[7]

t_array[:2, :3]

tensor([[0., 1., 2.],
        [5., 6., 7.]])

tensor operations

[8]

n1 = np.arange(10).reshape(2,5)

n2 = np.arange(10).reshape(5,2)

[9]

t1 = torch.FloatTensor(n1)

t2 = torch.FloatTensor(n2)

print('Shape of t1: ', t1.shape)

print('Shape of t2: ', t2.shape)

print(t1.matmul(t2))

Shape of t1: torch.Size([2, 5]) Shape of t2: torch.Size([5, 2]) tensor([[ 60., 70.], [160., 195.]])

[10]

n1.dot(n2)

array([[ 60,  70],
       [160, 195]])

[11]

n1 = np.arange(4).reshape(2,2)

n2 = np.arange(4).reshape(2,2)

t1 = torch.FloatTensor(n1)

t2 = torch.FloatTensor(n2)

 

t1 * t2

tensor([[0., 1.],
        [4., 9.]])

[12]

t1.mul(t2)

tensor([[0., 1.],
        [4., 9.]])

[13]

t1 * 5

tensor([[ 0.,  5.],
        [10., 15.]])

[14]

n1 = np.arange(10)

t1 = torch.FloatTensor(n1)

t1.mean()

tensor(4.5000)

[15]

n1 = np.arange(10).reshape(5,2)

t1 = torch.FloatTensor(n1)

t1.mean(dim=0)

tensor([4., 5.])

[16]

t1.mean(dim=1)

tensor([0.5000, 2.5000, 4.5000, 6.5000, 8.5000])

[17]

n1 = np.arange(10)

t1 = torch.FloatTensor(n1)

t1.view(-1, 2)

tensor([[0., 1.],
        [2., 3.],
        [4., 5.],
        [6., 7.],
        [8., 9.]])

[18]

n1.reshape(-1, 2)

array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])

[23]

t1.view(-1, 10)

tensor([[0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]])

[19]

t1.view(-1, 10).shape

torch.Size([1, 10])

[20]

t1.view(-1, 10).squeeze()

tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

[21]

t1.view(-1, 10).squeeze().unsqueeze(dim=0)

tensor([[0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]])

[22]

t1.view(-1, 10).squeeze().unsqueeze(dim=1)

tensor([[0.],
        [1.],
        [2.],
        [3.],
        [4.],
        [5.],
        [6.],
        [7.],
        [8.],
        [9.]])

tensor operations for ML/DL formula

[24]

import torch

import torch.nn.functional as F

[25]

tensor = torch.FloatTensor([0.5, 0.7, 0.1])

h_tensor = F.softmax(tensor, dim=0)

h_tensor

tensor([0.3458, 0.4224, 0.2318])

[26]

y = torch.randint(5, (10,5))

y_label = y.argmax(dim=1)

[27]

y_label

tensor([0, 1, 0, 1, 3, 0, 0, 3, 2, 2])

[28]

torch.nn.functional.one_hot(y_label)

 

tensor([[1, 0, 0, 0],
        [0, 1, 0, 0],
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 0, 1],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [0, 0, 0, 1],
        [0, 0, 1, 0],
        [0, 0, 1, 0]])

torch autogard

$$y=w^{2}z=2\ast y+5z=2\ast w^2+5$$

[29]

w = torch.tensor(2.0, requires_grad=True) # 미분 할건가 말건가

y = w**2

z = 2*y + 5

[30]

z.backward() # 미분이 일어나게 됨

[31]

w.grad

tensor(8.)

$$Q=3a^3-b^2$$

[32]

a = torch.tensor([2., 3.], requires_grad=True)

b = torch.tensor([6., 4.], requires_grad=True)

[33]

Q = 3*a**3 - b**2

 

[34]

external_grad = torch.tensor([1., 1.])

Q.backward(gradient=external_grad)

$$\frac{\partial Q}{\partial a}=9a^2$$

$$\frac{\partial Q}{\partial b}=-2b$$

[35]

a.grad

tensor([36., 81.])

[36]

b.grad

tensor([-12.,  -8.])

AutoGrad for Linear Regression

https://towardsdatascience.com/linear-regression-with-pytorch-eb6dedead817

$$y=2x+1$$

[37]

import numpy as np

# create dummy data for training

x_values = [i for i in range(11)]

x_train = np.array(x_values, dtype=np.float32)

x_train = x_train.reshape(-1, 1)

 

y_values = [2*i + 1 for i in x_values]

y_train = np.array(y_values, dtype=np.float32)

y_train = y_train.reshape(-1, 1)

[38]

x_train

array([[ 0.],
       [ 1.],
       [ 2.],
       [ 3.],
       [ 4.],
       [ 5.],
       [ 6.],
       [ 7.],
       [ 8.],
       [ 9.],
       [10.]], dtype=float32)

[39]

y_train

array([[ 1.],
       [ 3.],
       [ 5.],
       [ 7.],
       [ 9.],
       [11.],
       [13.],
       [15.],
       [17.],
       [19.],
       [21.]], dtype=float32)

[40]

# 선형은 y=Wx + b

import torch

from torch.autograd import Variable

class linearRegression(torch.nn.Module):

    def __init__(self, inputSize, outputSize):

        super(linearRegression, self).__init__()

        self.linear = torch.nn.Linear(inputSize, outputSize)

        # 항상 처음보는 코드는 따라 들어가서 코드레벨까지 보기

 

    def forward(self, x):

        out = self.linear(x)

        return out

[41]

inputDim = 1        # takes variable 'x' 

outputDim = 1       # takes variable 'y'

learningRate = 0.01 

epochs = 100

 

model = linearRegression(inputDim, outputDim)

##### For GPU #######

if torch.cuda.is_available():

    model.cuda()

[42]

criterion = torch.nn.MSELoss() 

optimizer = torch.optim.SGD(model.parameters(), lr=learningRate)

[43]

for epoch in range(epochs):

    # Converting inputs and labels to Variable

    if torch.cuda.is_available():

        inputs = Variable(torch.from_numpy(x_train).cuda())

        labels = Variable(torch.from_numpy(y_train).cuda())

    else:

        inputs = Variable(torch.from_numpy(x_train))

        labels = Variable(torch.from_numpy(y_train))

 

    # Clear gradient buffers because we don't want any gradient 

from previous epoch to carry forward, dont want to cummulate 

gradients

    # zero gradient를 항상 해줘야 쌓이는 것 없이 진행된다

    optimizer.zero_grad()

 

    # get output from the model, given the inputs

    outputs = model(inputs)

 

    # get loss for the predicted output

    loss = criterion(outputs, labels)

    print(loss)

    # get gradients w.r.t to parameters

    # backward 할 때마다 미분이 일어나지

    loss.backward()

 

    # update parameters

    optimizer.step()

 

    print('epoch {}, loss {}'.format(epoch, loss.item()))

tensor(206.3920, device='cuda:0', grad_fn=<MseLossBackward>) epoch 0, loss 206.3920440673828 tensor(16.8376, device='cuda:0', grad_fn=<MseLossBackward>) epoch 1, loss 16.83762550354004 tensor(1.3762, device='cuda:0', grad_fn=<MseLossBackward>) epoch 2, loss 1.376238465309143 tensor(0.1151, device='cuda:0', grad_fn=<MseLossBackward>) epoch 3, loss 0.11507002264261246 tensor(0.0122, device='cuda:0', grad_fn=<MseLossBackward>) epoch 4, loss 0.012168784625828266 tensor(0.0037, device='cuda:0', grad_fn=<MseLossBackward>) epoch 5, loss 0.0037444557528942823 tensor(0.0030, device='cuda:0', grad_fn=<MseLossBackward>) epoch 6, loss 0.003026577876880765 tensor(0.0029, device='cuda:0', grad_fn=<MseLossBackward>) epoch 7, loss 0.002937624929472804 tensor(0.0029, device='cuda:0', grad_fn=<MseLossBackward>) epoch 8, loss 0.0029003347735852003 tensor(0.0029, device='cuda:0', grad_fn=<MseLossBackward>) epoch 9, loss 0.0028675799258053303 tensor(0.0028, device='cuda:0', grad_fn=<MseLossBackward>) epoch 10, loss 0.002835528226569295 tensor(0.0028, device='cuda:0', grad_fn=<MseLossBackward>) epoch 11, loss 0.0028038672171533108 tensor(0.0028, device='cuda:0', grad_fn=<MseLossBackward>) epoch 12, loss 0.0027725582476705313 tensor(0.0027, device='cuda:0', grad_fn=<MseLossBackward>) epoch 13, loss 0.0027415987569838762 tensor(0.0027, device='cuda:0', grad_fn=<MseLossBackward>) epoch 14, loss 0.002710981061682105 tensor(0.0027, device='cuda:0', grad_fn=<MseLossBackward>) epoch 15, loss 0.002680701669305563 tensor(0.0027, device='cuda:0', grad_fn=<MseLossBackward>) epoch 16, loss 0.002650765236467123 tensor(0.0026, device='cuda:0', grad_fn=<MseLossBackward>) epoch 17, loss 0.0026211619842797518 tensor(0.0026, device='cuda:0', grad_fn=<MseLossBackward>) epoch 18, loss 0.002591898199170828 tensor(0.0026, device='cuda:0', grad_fn=<MseLossBackward>) epoch 19, loss 0.002562958048656583 tensor(0.0025, device='cuda:0', grad_fn=<MseLossBackward>) epoch 20, loss 0.00253433920443058 tensor(0.0025, device='cuda:0', grad_fn=<MseLossBackward>) epoch 21, loss 0.0025060418993234634 tensor(0.0025, device='cuda:0', grad_fn=<MseLossBackward>) epoch 22, loss 0.0024780421517789364 tensor(0.0025, device='cuda:0', grad_fn=<MseLossBackward>) epoch 23, loss 0.00245039165019989 tensor(0.0024, device='cuda:0', grad_fn=<MseLossBackward>) epoch 24, loss 0.0024230300914496183 tensor(0.0024, device='cuda:0', grad_fn=<MseLossBackward>) epoch 25, loss 0.002395971678197384 tensor(0.0024, device='cuda:0', grad_fn=<MseLossBackward>) epoch 26, loss 0.002369208261370659 tensor(0.0023, device='cuda:0', grad_fn=<MseLossBackward>) epoch 27, loss 0.0023427503183484077 tensor(0.0023, device='cuda:0', grad_fn=<MseLossBackward>) epoch 28, loss 0.0023165924940258265 tensor(0.0023, device='cuda:0', grad_fn=<MseLossBackward>) epoch 29, loss 0.0022907210513949394 tensor(0.0023, device='cuda:0', grad_fn=<MseLossBackward>) epoch 30, loss 0.002265149261802435 tensor(0.0022, device='cuda:0', grad_fn=<MseLossBackward>) epoch 31, loss 0.0022398445289582014 tensor(0.0022, device='cuda:0', grad_fn=<MseLossBackward>) epoch 32, loss 0.0022148259449750185 tensor(0.0022, device='cuda:0', grad_fn=<MseLossBackward>) epoch 33, loss 0.0021900965366512537 tensor(0.0022, device='cuda:0', grad_fn=<MseLossBackward>) epoch 34, loss 0.002165642101317644 tensor(0.0021, device='cuda:0', grad_fn=<MseLossBackward>) epoch 35, loss 0.0021414649672806263 tensor(0.0021, device='cuda:0', grad_fn=<MseLossBackward>) epoch 36, loss 0.002117547672241926 tensor(0.0021, device='cuda:0', grad_fn=<MseLossBackward>) epoch 37, loss 0.002093919087201357 tensor(0.0021, device='cuda:0', grad_fn=<MseLossBackward>) epoch 38, loss 0.0020705123897641897 tensor(0.0020, device='cuda:0', grad_fn=<MseLossBackward>) epoch 39, loss 0.002047403249889612 tensor(0.0020, device='cuda:0', grad_fn=<MseLossBackward>) epoch 40, loss 0.0020245348569005728 tensor(0.0020, device='cuda:0', grad_fn=<MseLossBackward>) epoch 41, loss 0.0020019125659018755 tensor(0.0020, device='cuda:0', grad_fn=<MseLossBackward>) epoch 42, loss 0.0019795664120465517 tensor(0.0020, device='cuda:0', grad_fn=<MseLossBackward>) epoch 43, loss 0.0019574754405766726 tensor(0.0019, device='cuda:0', grad_fn=<MseLossBackward>) epoch 44, loss 0.0019356186967343092 tensor(0.0019, device='cuda:0', grad_fn=<MseLossBackward>) epoch 45, loss 0.001913992571644485 tensor(0.0019, device='cuda:0', grad_fn=<MseLossBackward>) epoch 46, loss 0.001892620581202209 tensor(0.0019, device='cuda:0', grad_fn=<MseLossBackward>) epoch 47, loss 0.0018714822363108397 tensor(0.0019, device='cuda:0', grad_fn=<MseLossBackward>) epoch 48, loss 0.0018505867337808013 tensor(0.0018, device='cuda:0', grad_fn=<MseLossBackward>) epoch 49, loss 0.0018299183575436473 tensor(0.0018, device='cuda:0', grad_fn=<MseLossBackward>) epoch 50, loss 0.0018094833940267563 tensor(0.0018, device='cuda:0', grad_fn=<MseLossBackward>) epoch 51, loss 0.0017892859177663922 tensor(0.0018, device='cuda:0', grad_fn=<MseLossBackward>) epoch 52, loss 0.0017693080008029938 tensor(0.0017, device='cuda:0', grad_fn=<MseLossBackward>) epoch 53, loss 0.0017495357897132635 tensor(0.0017, device='cuda:0', grad_fn=<MseLossBackward>) epoch 54, loss 0.0017300068866461515 tensor(0.0017, device='cuda:0', grad_fn=<MseLossBackward>) epoch 55, loss 0.001710680779069662 tensor(0.0017, device='cuda:0', grad_fn=<MseLossBackward>) epoch 56, loss 0.0016915786545723677 tensor(0.0017, device='cuda:0', grad_fn=<MseLossBackward>) epoch 57, loss 0.001672690617851913 tensor(0.0017, device='cuda:0', grad_fn=<MseLossBackward>) epoch 58, loss 0.0016540165524929762 tensor(0.0016, device='cuda:0', grad_fn=<MseLossBackward>) epoch 59, loss 0.0016355657717213035 tensor(0.0016, device='cuda:0', grad_fn=<MseLossBackward>) epoch 60, loss 0.0016172955511137843 tensor(0.0016, device='cuda:0', grad_fn=<MseLossBackward>) epoch 61, loss 0.001599231269210577 tensor(0.0016, device='cuda:0', grad_fn=<MseLossBackward>) epoch 62, loss 0.0015813630307093263 tensor(0.0016, device='cuda:0', grad_fn=<MseLossBackward>) epoch 63, loss 0.0015636991010978818 tensor(0.0015, device='cuda:0', grad_fn=<MseLossBackward>) epoch 64, loss 0.0015462442534044385 tensor(0.0015, device='cuda:0', grad_fn=<MseLossBackward>) epoch 65, loss 0.0015289830043911934 tensor(0.0015, device='cuda:0', grad_fn=<MseLossBackward>) epoch 66, loss 0.0015118996379896998 tensor(0.0015, device='cuda:0', grad_fn=<MseLossBackward>) epoch 67, loss 0.0014950240729376674 tensor(0.0015, device='cuda:0', grad_fn=<MseLossBackward>) epoch 68, loss 0.001478330697864294 tensor(0.0015, device='cuda:0', grad_fn=<MseLossBackward>) epoch 69, loss 0.0014618198620155454 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 70, loss 0.0014455093769356608 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 71, loss 0.0014293610583990812 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 72, loss 0.0014133971417322755 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 73, loss 0.0013976226327940822 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 74, loss 0.001382010756060481 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 75, loss 0.0013665799051523209 tensor(0.0014, device='cuda:0', grad_fn=<MseLossBackward>) epoch 76, loss 0.0013513071462512016 tensor(0.0013, device='cuda:0', grad_fn=<MseLossBackward>) epoch 77, loss 0.0013362137833610177 tensor(0.0013, device='cuda:0', grad_fn=<MseLossBackward>) epoch 78, loss 0.001321309246122837 tensor(0.0013, device='cuda:0', grad_fn=<MseLossBackward>) epoch 79, loss 0.0013065504608675838 tensor(0.0013, device='cuda:0', grad_fn=<MseLossBackward>) epoch 80, loss 0.0012919578002765775 tensor(0.0013, device='cuda:0', grad_fn=<MseLossBackward>) epoch 81, loss 0.00127753138076514 tensor(0.0013, device='cuda:0', grad_fn=<MseLossBackward>) epoch 82, loss 0.0012632724829018116 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 83, loss 0.0012491564266383648 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 84, loss 0.0012352198828011751 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 85, loss 0.0012214111629873514 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 86, loss 0.0012077799765393138 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 87, loss 0.0011942884884774685 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 88, loss 0.001180959166958928 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 89, loss 0.0011677742004394531 tensor(0.0012, device='cuda:0', grad_fn=<MseLossBackward>) epoch 90, loss 0.0011547371977940202 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 91, loss 0.0011418408248573542 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 92, loss 0.0011290920665487647 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 93, loss 0.0011164796305820346 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 94, loss 0.0011040170211344957 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 95, loss 0.0010916816536337137 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 96, loss 0.001079498790204525 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 97, loss 0.0010674381628632545 tensor(0.0011, device='cuda:0', grad_fn=<MseLossBackward>) epoch 98, loss 0.0010555178159847856 tensor(0.0010, device='cuda:0', grad_fn=<MseLossBackward>) epoch 99, loss 0.0010437151649966836

[44]

with torch.no_grad(): # we don't need gradients in the testing phase

    if torch.cuda.is_available():

        predicted = model(Variable(torch.from_numpy(x_train).cuda())

).cpu().data.numpy()

    else:

        predicted = model(Variable(torch.from_numpy(x_train)))

.data.numpy()

    print(predicted)

 

[[ 1.0600971] [ 3.0514426] [ 5.042788 ] [ 7.0341334] [ 9.025478 ] [11.016824 ] [13.008169 ] [14.999515 ] [16.99086 ] [18.982206 ] [20.97355 ]]

[-]

 

[DLBasic] 뉴럴 네트워크 - MLP

인간의 뇌를 모방했다고 잘 된다하고 끝나는게 아니라 이게 왜 잘되는지를 분석하는게 중요하다..

y-hat은 내가 현재 예측한 출력값

각각 w와 b에 관해 loss function 편미분해서 새로운 w,b

행렬을 곱한다는 것을 해석하면 두 개의 vector space 의 변환. 선형 회귀에선 서로 다른 차원 사이의 선형 변환 이겠지.. weight

내가 필요한 것은 바로 (p) 이 중간의 Nonlinear transform. 결국은 x라는 입력에서 y로 출력하는 맵핑이 표현할 수 있는 cupacity . 네트워크가 표현할 수 있는 표현력을 최대한 극대화 하기 위해서는 단순히 선형결합을 n번 반복하는게 아니라 한번 선형결합이 반복되면 그 뒤에 activatation function을 이용해서 nonlinear function 을 거치고 그렇게 얻어지는 feature vector를 다시 선형변환을 하고 다시 transform을 거치고.. 얘를 n번 반복하게 되면 더 많은 표현력을 얻게 되는 것. 그게 neural networks

각 loss function의 특징은 뭐고 내가 원하는 결과를 얻을 수 있는지. 

예를들면 Regression Task 문제에서 MSE는 혼자 튀어있는 값 예측하려다 전체가 망가진다

Classification Task 에선 CE를 쓰는데 one hot vector를 쓴다. 걔만 1이고 나머진 다 0. 그럼 percentage 로써 minimize 한다는게 뭐냐면 y-hat이라고 불리우는 걸 (logic) 내 neural networks의 출력값중에서 해당하는 클래스에 값만 높이겠다는 의미. 걔가 다른 애들에 비해 얼마나 높아질지가 중요한게 아니라 그 차원에 해당하는 출력값을 키우는게 목적. 키운다는건 얘가 10이어도 되고 10000이어도 되고. 근데 분류한다고 했을 때 (길게 나오는 라벨 문제를 풀 때) 결과가 나왔을 때 긴 결과 중에서 제일 큰 숫자가 들어있는 index만 고려하기 때문에 (숫자 크기에 상관없이) 그럼 분류를 잘 할 수 있다. 다른 값을 대비 높기만 하면 된다. 근데 그걸 수학적으로 세우는게 까다로우니까 cross entropy loss function 을 사용하는 것. 그래서 이게 최선일까 아는 것.

Probabilistic Task에선 결과가 단순히 출력값이 아니라 확률적인 모델을 하고 싶을 때, 사람 나이를 맞출 때 이사람은 20살이다, 32살이다가 아닌 32살인것 같은데 음.. 하는 확실하지 않은 정보를 찾고 싶을 때 활용한다 한다.

Multi Layer Perceptron

[1]

import numpy as np

import torch

from torch import nn, optim

from torch.nn import functional as F

from torchvision import datasets, transforms

import matplotlib.pyplot as plt

%matplotlib inline  

%config InlineBackend.figure_format='retina'

print ("PyTorch version:[%s]."%(torch.__version__))

 

# Device Configuration

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

print ("This notebook use [%s]."%(device))

PyTorch version:[1.7.0+cu101]. This notebook use [cuda:0].

Set hyper-parameter

[2]

EPOCHS = 10

BATCH_SIZE=256

LEARNING_RATE=0.001

Prepare datadaset

[3]

from torchvision import datasets, transforms

# MNIST dataset

mnist_train = datasets.MNIST(root='./data/', train=True, 

transform=transforms.ToTensor(), download=True)

mnist_test = datasets.MNIST(root='./data/', train=False, 

transform=transforms.ToTensor(), download=True)

 

train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=BATCH_SIZE, 

shuffle=True, num_workers=1)

test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=BATCH_SIZE, 

shuffle=True, num_workers=1)

 

print("Preparing dataset done!")

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz

Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz

Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz

Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz

Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw Processing... Done! Preparing dataset done!

/usr/local/lib/python3.6/dist-packages/torchvision/datasets/mnist.py:480: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /pytorch/torch/csrc/utils/tensor_numpy.cpp:141.) return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)

Defining Model

[6]

# our model

class Model(nn.Module):

    def __init__(self, input_features=784, hidden_size=256, output_fetures=10, 

init_weight="he", init_bias="zero"):

        super(Model, self).__init__()

        self.init_weight = init_weight

        self.init_bias = init_bias

 

        self.linear1 = nn.Linear(input_features, hidden_size)

        self.linear2 = nn.Linear(hidden_size, output_fetures)

        self.init_params()

 

    def init_params(self):

        

        init_weight_method = {

        "he": nn.init.kaiming_normal_, 

        "xavier": nn.init.xavier_normal_

        }

        assert self.init_weight in init_weight_method.keys(), f'Select the weight 

initialization method in {list(init_weight_method.keys())}'

        

        init_bias_method = {

            "zero": nn.init.zeros_, 

            "uniform": nn.init.uniform_

        }

        assert self.init_bias in init_bias_method.keys(), f'Select the bias 

initialization method in {list(init_bias_method.keys())}'

 

        for param_name, param in self.named_parameters():

            if 'weight' in param_name:

                print(param)

                init_weight_method[self.init_weight](param)

            elif 'bias' in param_name:

                init_bias_method[self.init_bias](param)

 

    def forward(self, X):

        X = F.relu((self.linear1(X)))

        X = self.linear2(X)

        return X

 

model = Model().to(device)

criterion = nn.CrossEntropyLoss()

optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)

Parameter containing: tensor([[-0.0335, 0.0279, 0.0111, ..., 0.0185, -0.0299, 0.0354], [ 0.0017, -0.0137, -0.0328, ..., -0.0071, -0.0177, 0.0301], [ 0.0137, -0.0347, 0.0026, ..., 0.0315, 0.0101, -0.0186], ..., [ 0.0214, 0.0294, 0.0345, ..., 0.0171, 0.0251, -0.0048], [ 0.0145, -0.0284, -0.0220, ..., 0.0324, -0.0142, 0.0303], [ 0.0072, 0.0038, -0.0173, ..., -0.0091, 0.0102, 0.0317]], requires_grad=True) Parameter containing: tensor([[ 0.0580, 0.0524, -0.0219, ..., 0.0498, -0.0375, 0.0541], [-0.0622, 0.0236, 0.0334, ..., 0.0192, 0.0413, 0.0425], [ 0.0359, 0.0294, 0.0211, ..., -0.0442, 0.0171, -0.0505], ..., [ 0.0247, 0.0003, 0.0325, ..., 0.0216, 0.0352, 0.0252], [ 0.0062, 0.0105, 0.0186, ..., -0.0512, 0.0321, 0.0067], [-0.0245, -0.0098, 0.0387, ..., -0.0268, -0.0132, -0.0419]], requires_grad=True)

[9]

total_params = 0

for p_idx, (param_name, param) in enumerate(model.named_parameters()):

  param_numpy = param.detach().cpu().numpy()

  print(f"{p_idx} name:[{param_name}] shape:[{param.shape}].")

  print(f"   val:{param_numpy.reshape(-1)[:5]}")

  if param.requires_grad:

    total_params += len(param.reshape(-1))

print(f"Number of Total Parameters: {total_params:,d}")

# (256*784) + (256*10) + 256 + 10 = 203530

0 name:[linear1.weight] shape:[torch.Size([256, 784])]. val:[ 0.01886598 -0.04076248 -0.00660198 -0.00844585 -0.03178782] 1 name:[linear1.bias] shape:[torch.Size([256])]. val:[0. 0. 0. 0. 0.] 2 name:[linear2.weight] shape:[torch.Size([10, 256])]. val:[-0.05692727 -0.00400193 0.0784019 0.15648389 0.10338839] 3 name:[linear2.bias] shape:[torch.Size([10])]. val:[0. 0. 0. 0. 0.] Number of Total Parameters: 203,530

Define help function

[10]

def test_eval(model, data_iter, batch_size):

    with torch.no_grad():

        model.eval() # evaluate (affects DropOut and BN)

        test_loss = 0

        total = 0

        correct = 0

        for batch_img, batch_lab in data_iter:

            X = batch_img.view(-1, 28*28).to(device)

            Y = batch_lab.to(device)

            y_pred = model(X)

            _, predicted = torch.max(y_pred.data, 1)

            correct += (predicted == Y).sum().item()

            total += batch_img.size(0)

        val_acc = (100 * correct / total)

    return val_acc

Initial Evaluation

[12]

train_accr = test_eval(model, train_iter,BATCH_SIZE)

test_accr = test_eval(model, test_iter,BATCH_SIZE)

print("train_accr:[{:.3f}] test_accr:[{:.3f}].".format(train_accr, test_accr))

train_accr:[10.075] test_accr:[9.660].

Train MLP Model

[13]

# Training Phase

print_every = 1

print("Start training !")

# Training loop

for epoch in range(EPOCHS):

    loss_val_sum = 0

    for batch_img, batch_lab in train_iter:

 

        X = batch_img.view(-1, 28*28).to(device)

        Y = batch_lab.to(device)

        

        # Inference & Calculate los

        y_pred = model.forward(X)

        loss = criterion(y_pred, Y)

        

        # update

        optimizer.zero_grad() # reset gradient

        loss.backward() # backpropagate. 각각의 weight에 대해서 loss가 쌓여있게 됨

        optimizer.step() # backpropagate를 통해 나온 결과들을 weight를 옮겨주게 됨

        

        loss_val_sum += loss

        

    if ((epoch%print_every)==0) or (epoch==(EPOCHS-1)):

        # accr_val = M.test(x_test, y_test, batch_size)

        loss_val_avg = loss_val_sum / len(train_iter)

        accr_val = test_eval(model, test_iter, BATCH_SIZE)

        print(f"epoch:[{epoch+1}/{EPOCHS}] cost:[{loss_val_avg:.3f}] 

test_accuracy:[{accr_val:.3f}]")

print("Training Done !")

Start training ! epoch:[1/10] cost:[0.380] test_accuracy:[94.230] epoch:[2/10] cost:[0.163] test_accuracy:[96.110] epoch:[3/10] cost:[0.115] test_accuracy:[96.790] epoch:[4/10] cost:[0.087] test_accuracy:[97.270] epoch:[5/10] cost:[0.070] test_accuracy:[97.430] epoch:[6/10] cost:[0.057] test_accuracy:[97.420] epoch:[7/10] cost:[0.047] test_accuracy:[97.860] epoch:[8/10] cost:[0.039] test_accuracy:[97.800] epoch:[9/10] cost:[0.032] test_accuracy:[97.770] epoch:[10/10] cost:[0.028] test_accuracy:[97.790] Training Done !

Test MLP Model

[14]

n_sample = 64

sample_indices = np.random.choice(len(mnist_test.targets), n_sample, 

replace=False)

test_x = mnist_test.data[sample_indices]

test_y = mnist_test.targets[sample_indices]

 

with torch.no_grad():

    y_pred = model.forward(test_x.view(-1, 28*28).type(torch.float).to(device))

 

y_pred = y_pred.argmax(axis=1)

 

plt.figure(figsize=(20, 20))

 

for idx in range(n_sample):

    plt.subplot(8, 8, idx+1)

    plt.imshow(test_x[idx], cmap='gray')

    plt.axis('off')

    plt.title(f"Predict: {y_pred[idx]}, Label: {test_y[idx]}")

 

plt.show()

[DLBasic] 데이터셋 다루기

모듈화를 하는것이 중요하다. 블록을 만들듯이 얘 끼워넣고 얘 끼워넣고..

class MyDataset(torch.utils.data.Dataset):

    def __init__(self, x_data, y_data):

        self.x_data = x_data

        self.y_data = y_data

    def __len__(self):

        return len(self.y_data)

    def __getitem__(self, idx):

        x = torch.FloatTensor(self.x_data[idx])

        y = torch.FloatTensor(self.y_data[idx])

        return x, y

보통 torch.utils.data.Dataset 을 받아서 데이터셋을 만듬

__init__ 은 초기값 설정

__len__ 은 데이터의 전체길이

__getitem__ 은 iterator를 부를 때 특정한 index 값을 가지고 부르게 되는데 그 index 값을 부를 때 tensor 식으로 항상 변환해서 반환해야 함.

데이터로더는 어떻게 쓸건가

=======================

과제 / 퀴즈

어려운거 없었음

======================

피어세션

엔트로피는 그냥 데이터값이라 상수라서 크로스 엔트로피만 보는거다

ppt에도 오타가 있을 수 있음을 명심하라

=========================

후기

환경설정하느라 시간 다 잡아먹어서 매우 늦게 끝났다. 피곤하다.

같이 하던 한 분이 안타깝게도 건강 상 그만두신다고 한다. 건강관리에 신경써야겠다.