과거의 것들/AI Tech boostcamp

AITech 학습정리-[DAY 14] Recurrent Neural Networks

용나리 2021. 11. 27. 00:00

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

학습내용

[AI Math 10강] RNN 첫걸음

sequence 데이터를 학습한다. 시계열. 독립된 데이터가 아님. 왜 이렇게 설계하는지 이해하는게 중요하다.

소리, 문자열 주가 등..

시퀀스 데이터는 독립동등분포(i.i.d.) 가정을 잘 위배하기 때문에 순서를 바꾸거나 과거 정보에 손실이 발생하면 데이터의 확률분포도 바뀌게 된다.

A와 B가 독립시행일 경우 P(A∩B) = P(A)*P(B)

앞의 조건가지고 뒤가 달라지기 때문에 조건부 확률을 사용할 수 있다. 베이즈 법칙으로 쪼갤 수 있음. (https://ko.wikipedia.org/wiki/%EB%B2%A0%EC%9D%B4%EC%A6%88_%EC%A0%95%EB%A6%AC)

과거의 모든 데이터를 쓰는건 아니고 최근의 정보를 주로 다루는 것. 다 필요없는 경우가 많으니까. 어떻게 다룰지는 모델링에 다라 다를 수 있다.

고정된 길이 tau만큼의 시퀀스만 사용하는 경우 AR(tau)(Autoregressive Model) 자귀회귀모델이라고 부른다. 이런 방법도 있다. 이 경우 고정이기 때문에 어떨땐 가까운것만 필요하고 어떨땐 먼 과거가 필요할 때도 있다. 어떻게 모델링 할건가?

현재와 바로과거 직전 빼고 그 더 과거들을 묶어서 잠재변수 Ht라고 하고 인코딩한다. 이렇게 하면 바로 이전 직전의 정보랑 잠재변수 두 가지 데이터만 가지고 현재시점 미래시점 예측이 가능하기 때문에. 가변적이지 않고 고정된 길이의 모델링 할 수 있다. 과거의 모든 데이터를 가지고 훈련하고 가변적인 데이터 문제를 고정된 길이로 훈련할 수 있기 때문에 여러가지 장점이 가지고 있는 모델이다.

문제는 어떻게 인코딩 할지.

순환신경망.

가장 기본적인 RNN 모델은 MLP와 유사한 모양이라 과거 정보를 다룰 수 없다.

Xt -> Ht -> Ot

과거 정보가 안들어감.

W2와 Wx1, Wh1 이 3개 가중치 행렬은 t에 따라 변하지 않는 행렬이다. 즉 t에 따라 변하는 것은 입력데이터와 잠재변수.

t에 독립적인 가중치 행렬은 동일하게 작용된다. 각각의 t 시점에 활용된다.

RNN의 역전파도 거꾸로지만 잠재그래프의 연결에 따라서 순차적으로 진행된다. 맨 마지막 gradient가 타고 들어와서 과거까지 흐른다. Backpropagation Through Time BPTT. 미래 Ht+1와 결과 Ot+1 두개가 잠재변수 Ht에 들어온다. 이 Ht를 입력과 그 이전 Ht-1에 넣고 학습이 이루어 진다.

저 불안정한 부분이 길이에 따라 달라지는데 미분값이 엄청 커지거나 작아지거나 한다. 그래서 gradient를 모두 곱해주는 형태라 BPTT를 모든 t시점에서 학습하면 RNN 학습 network가 불안정해지기 쉽다.

기울기가 0으로 vanishing 되는건 큰 문제가 된다. 과거로 갈 수록 gradient가 점점 0이 된다면 과거 정보가 유실되서 문맥같은 이전 정보가 필요한 곳에 문제가 될 수 있다. 문제 해결하려고 쓰는게 truncated BPTT. BPTT의 모든 시점을 계산하는게 아니라 미래의 정보들 중 몇개는 끊고 오로지 과거의 정보에 해당하는 몇 개의 block을 나눠서 backpropagation에 연산을 하는 과정이다. 잠재변수에 들어오는 gradient들을 쭉 받아올텐데 미래시점에서부터 t+1 시점까지 들어오게 되는 gradient는 같다가 여기서부터 들어오는 gradient를 H에 전달하지 않고 Ht는 오로지 출력에서 들어오는 gradient인 Ot에서만 gradient를 받아서 Ht에 전달을 하는 것이다. 그래서 이런식으로 gradient를 전달을 할 때 모든 t시점에서 전달하지 않고 특정 bolck에서 끊고 gradient를 나눠서 전달하는 방식이다. 이걸로 gradient vanshing을 해결할 수 있다.

사실 완벽한 해결책이 되는건 아니다. 오늘날엔 vanishing 문제때문에 기본적인 RNN 모델은 사용하지 않고 LSTM이나 GRU라는 발전된 neural network를 사용한다.

[DLBasic] Sequential Models - RNN

sequence 에서의 어려움은? 결국 원하는 건 하나의 label. sequencal data는 길이가 얼마인지 몰라서 차원을 결정하기 힘듬. 몇개의 단어, 이미지들이 들어올 지 어떻게 알아.

가장 기본적인 sequencial 모델은 다음에 어떤게 나올지 예측하는 거. 시간이 지날수록 고려해야 되는 정보량이 늘어나긴 한다. 이게 어려움. 가장 간단히 만들려면? 고정적으로 과거의 몇개만 보는것. tau가 5면 난 과거의 5개만 가지고 예측하겠어.

이런거의 제일 쉬운 방법이 Markov model(first-order autoregressive model). 나의 현재는 과거에만 dependent 하다는 가정.

근데 별로겠지. 어제 공부한 양만 가지고 내일 수능 점수를 예측하는 꼴.. 과거의 많은 정보를 버릴 수 밖에 없게되지만 어쨌든 사용하게 되면 가장 큰 장점은 joint distribution을 하는게 쉬워짐 (나중에 배운다 함)

그래서 이렇게 하지말고 Latent autoregressive model. 사실 과거의 엄청 많은 정보를 고려해야 되는데 할 수 없어서 나온거. 중간에 hidden state가 들어가 있어서 과거의 정보를 summary 하고 다음의 time step은 이 h에 dependent 한 것.

이런 개념들을 잘 쉽게 구현한 것이 Recurrent Neural Network. 자기 자신으로 돌아가는 구조가 하나 있는 것. 그래서 ht는 xt에만 dependent 한게 아니라 이전의 t-1 전에서 얻어진 어떤 cell state에 dependent 하게 되는 것.

x와 A에서 나온 결과랑 합쳐줘서 h.

그림 출처들은 이 사람꺼 블로그다.

단점은 과거에 얻어진 정보들이 summarize. 다 취합되서 미래에서 온거라. RNN 자체는 하나의 fixrule로 계속 취합한 거라 과거 정보가 미래에까지 살아남기 힘듬. 가까운건 고려가 잘 되는데 먼 과거는 잘 안됨. 영어 문장을 생각해보면 과거의 중요한 단어도 잘 기억했다가 결과내야 하는데 5초밖에 고려 못한다. 이게 가장 큰 단점. 이걸 극복하기 위해 나온게 LSTM.

sigmoid 같은 activation function 을 계속 곱하면 작아져서 의미가 없어지게 되겠지. reLU도 어쩌다보니 양수가 나오면 엄청 크게 바껴서 중첩되 학습 network가 폭발된다.

이 구조가 어떻게 Long Term 이 되는지 알아보자...

x는 입력. language model이라면 5만개 단어일 수 있고(사실 embedding vector로 들어가긴 할거지만). h는 output(hidden state).

위 쪽 라인의 Previous cell state 내부에서만 흘러가고 결과적으로는 지금까지 time step 0부터 t까지 들어왔던 t+1개의 정보를 다 취합해서 summarize 해주는 정보.

밑 라인은 Previous hidden state. output이 위로 나오기도 하지만 아래로 흘러간다. 아래로 흘러간 건 t+1번째 lstm에 previous hidden state로 들어가겠지. lstm이 입력으로 들어가는 건 이전의 출력값 (previous hidden state) 와 밖으로는 나가지 않는 previous cell state, 현재 time step t번째 입력 . 들어오는 입력 3개 나가는 입력 3개. 어쨋든 실제로 나가는건 hidden state 밖에 없음.

안을 자세히 보면 sigmoid가 3개. lstm은 gate 위주로 이해하면 좋은데 3개 gate.

lstm의 가장 큰 아이디어는 중간에 흘러가는 cell state. 어떤 컨베이어 벨트라고 보면 된다. 물건이 올라오면 컨베이어 벨트 조작공들이 이 정보를 잘 조작해서 어떤 정보가 유용하고 유용하지 않은 지를 가지고 다음번에 넘겨준다. 이 어떤걸 올리고 어떤걸 빼고 조작할지에 대한 정보가 gate.

Forget Gate는 어떤 정보를 버릴지. 입력으로 들어가는건 현재입력 xt와 이전의 output ht-1 을 조합해서 ft를 얻게 됨. sigmoid를 통과하기 때문에 ft는 항상 0~1 값을 갖게 됨. 뒤에서 ft의 역할은 ft가 이전에 나온 cell state 정보중에 어떤거를 버리고 어떤걸 살릴지를 정해준다. 이걸 이전의 previous hidden state와 현재입력을 가지고 weight를 곱하고 activation을 통과시켜서 이전의 cell state에서 넘어오는 정보중에서 버릴거를 정한다.

Input Gate는 현재 입력이 들어왔는데 얘를 무작정 cell state에다 올리는게 아니라 이 정보중에 어떤 정보를 올릴지 말지를 정함. it는 이전의 이전의 previous hidden state와 현재 입력을 가지고 it라는 정보를 만들게 됨. it는 말 그대로 어떤 정보를 cell state에 추가할지. 추가로 알아야 할 건 올릴 정보를 알아야 한다. cell state candidate. 이전의 cell state 와 현재 입력이 들어와서 따로 학습되는 다른 neural network 를 통해서 tanh를 통과해서 나오는 모든 값이 - + 로 정규화 되있는 Ctilda 라는걸 만든다. 궁극적으로는 Ctilda가 현재 정보와 이전 출력값을 가지고 만들어지는 Cell state 예비군. 그럼 이전까지 summarize 되었던 cell state와 현재 정보와 이전 output으로 얻어진 cell state candidate를 잘 섞어서 새로운 cell state에 업데이트 해줘야 한다.

어떤 값을 올릴지 Ctilda.

그래서 update cell 부분이 있는데 여기선 뭘 해주냐면 위에서 본 it가 나와서 ft에서 나온 것 만큼 이전 Ct-1 만큼 곱해서 버릴건 버리고 input gate에서 나왔던 Ctilda를 가지고 it만큼 곱해서 어느 값을 올릴지를 정해서 이 두 값을 combine 한 걸 새로운 cell state로 업데이트 한다. 버릴건 버리고 현재정보 기준으로 쓸건 쓰고, 합쳐서 새로운 cell state 를 update.

이제 출력값을 뽑아내야 겠지. 그대로 cell state out을 뽑아낼 수도 있고 그걸 GRU에서 하는거. LSTM에선 한번 더 조작한다. 어떤 값을 밖으로 내보낼 지에 해당하는 output gate를 만들고 그 output gate 만큼 곱해서 (element wise multiplication 해서) 현재 output이 나오고 얘가 next hidden state로 흘러가는 것.

이 네가지를 잘 조합한게 lstm. 이전까지 들어왔던 정보들을 현재 입력을 바탕으로 지울지, 현재 입력을 바탕으로 어떤 값을 새롭게 쓸지, 이 두 정보를 취합하는게 update cell이고 이 취합된 cell state를 한번 더 조작해서 어떤 값을 밖으로 빼낼지를 정하는게 output gate.

input, previous hidden state, previous cell state가 안으로 들어오게 되면 어떤 정보를 먼저 이전 cell state를 얼마나 지워버릴 지를 정하고 previous hidden state와 input을 가지고 어떤 값을 올릴지 Ctilda를 정하고 그 2두개 update 된 cell state와 현재 내가 올릴 candidate state를 다시 조합해서 새로운 cell state를 만들고 그 정보를 얼만큼 밖으로 빼낼지를 정해서 최종 출력값이 나오는 것.

GRU. 일반적으로 rnn을 쓴다고 하면 3가지. 기본적인 바닐라 rnn과 lstm, gru. gate가 2개. cell state가 없다. hidden state가 곧 output이고 걔가 다음 번에 들어가게 됨. cell state가 없고 hidden state가 바로 있게 되서 output gate가 필요없어진거고 그 대신에 reset gate와 update gate. reset gate가 위에서 본 forget gate와 비슷한 것 같다. 이렇게 두 개의 gate 가지고 lstm과 비슷한 역할을 하게 된다. 그래서 lstm 쓸때보다 GRU를 사용할 때 성능이 올라가는 경우가 꽤 있다..

근데 현재는 transformer가 나오면서 이런것들이 잘 안쓰이고 바뀌고 있다.

실습

Classification with LSTM

[1]

import numpy as np

import matplotlib.pyplot as plt

import torch

import torch.nn as nn

import torch.optim as optim

import torch.nn.functional as F

%matplotlib inline

%config InlineBackend.figure_format='retina'

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

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

print ("device:[%s]."%(device))

PyTorch version:[1.7.0+cu101]. device:[cuda:0].

Dataset and Loader

[2]

from torchvision import datasets,transforms

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)

BATCH_SIZE = 256

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 ("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! 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)

Define Model

[3]

class RecurrentNeuralNetworkClass(nn.Module):

def __init__(self,name='rnn',xdim=28,hdim=256,ydim=10,n_layer=3):

super(RecurrentNeuralNetworkClass,self).__init__()

self.name = name

self.xdim = xdim

self.hdim = hdim

self.ydim = ydim

self.n_layer = n_layer # K

self.rnn = nn.LSTM(

input_size=self.xdim,hidden_size=self.hdim,num_layers=self.n_layer,

batch_first=True)

self.lin = nn.Linear(self.hdim,self.ydim)

def forward(self,x):

# Set initial hidden and cell states

h0 = torch.zeros(self.n_layer,x.size(0),self.hdim).to(device)

c0 = torch.zeros(self.n_layer,x.size(0),self.hdim).to(device)

# RNN

rnn_out,(hn,cn) = self.rnn(x, (h0,c0))

# x:[N x L x Q] => rnn_out:[N x L x D]

# Linear

out = self.lin(rnn_out[:,-1 :]).view([-1,self.ydim])

# 배치마다 logisitic 이 나옴. argmax로 . 확률로 얻어진다.

return out

R = RecurrentNeuralNetworkClass(

name='rnn',xdim=28,hdim=256,ydim=10,n_layer=2).to(device)

loss = nn.CrossEntropyLoss()

optm = optim.Adam(R.parameters(),lr=1e-3)

print ("Done.")

Done.

Check How LSTM Works

N: number of batches
L: sequence lengh
Q: input dim
K: number of layers
D: LSTM feature dimension

Y,(hn,cn) = LSTM(X)

X: N x L x Q - N input sequnce of length L with Q dim.
Y: N x L x D - N output sequnce of length L with D feature dim.
hn: K x N x D - K (per each layer) of N final hidden state with D feature dim.
cn: K x N x D - K (per each layer) of N final hidden state with D cell dim.

[4]

np.set_printoptions(precision=3)

torch.set_printoptions(precision=3)

x_numpy = np.random.rand(2,20,28) # [N x L x Q]

x_torch = torch.from_numpy(x_numpy).float().to(device)

rnn_out,(hn,cn) = R.rnn(x_torch) # forward path

print ("rnn_out:",rnn_out.shape) # [N x L x D]

print ("Hidden State hn:",hn.shape) # [K x N x D]

print ("Cell States cn:",cn.shape) # [K x N x D]

rnn_out: torch.Size([2, 20, 256]) Hidden State hn: torch.Size([2, 2, 256]) Cell States cn: torch.Size([2, 2, 256])

Check parameters

[5]

np.set_printoptions(precision=3)

n_param = 0

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

if param.requires_grad:

param_numpy = param.detach().cpu().numpy() # to numpy array

n_param += len(param_numpy.reshape(-1))

print ("[%d] name:[%s] shape:[%s]."%(p_idx,param_name,param_numpy.shape))

print (" val:%s"%(param_numpy.reshape(-1)[:5]))

print ("Total number of parameters:[%s]."%(format(n_param,',d')))

[0] name:[rnn.weight_ih_l0] shape:[(1024, 28)]. val:[-0.004 -0.055 -0.006 0.044 0.044] [1] name:[rnn.weight_hh_l0] shape:[(1024, 256)]. val:[-0.029 0.052 0.025 -0.025 -0.04 ] [2] name:[rnn.bias_ih_l0] shape:[(1024,)]. val:[-0.024 0.015 0.046 -0.043 -0.031] [3] name:[rnn.bias_hh_l0] shape:[(1024,)]. val:[ 0.06 -0.049 -0.027 0.028 0.022] [4] name:[rnn.weight_ih_l1] shape:[(1024, 256)]. val:[-0.047 -0.051 -0.017 0.039 0.025] [5] name:[rnn.weight_hh_l1] shape:[(1024, 256)]. val:[-0.013 -0.042 -0.024 0.026 -0.017] [6] name:[rnn.bias_ih_l1] shape:[(1024,)]. val:[-0.046 0.011 -0.059 0.02 -0.056] [7] name:[rnn.bias_hh_l1] shape:[(1024,)]. val:[ 0.06 0.002 0.049 0.012 -0.048] [8] name:[lin.weight] shape:[(10, 256)]. val:[-0.032 -0.004 0.016 0.021 -0.035] [9] name:[lin.bias] shape:[(10,)]. val:[-0.028 -0.045 0.062 0.004 -0.061] Total number of parameters:[821,770].

Simple Forward Path

[6]

np.set_printoptions(precision=3)

torch.set_printoptions(precision=3)

x_numpy = np.random.rand(3,10,28) # [N x L x Q]

x_torch = torch.from_numpy(x_numpy).float().to(device)

y_torch = R.forward(x_torch) # [N x 1 x R] where R is the output dim.

y_numpy = y_torch.detach().cpu().numpy() # torch tensor to numpy array

# print ("x_torch:\n",x_torch)

# print ("y_torch:\n",y_torch)

print ("x_numpy %s"%(x_numpy.shape,))

print ("y_numpy %s"%(y_numpy.shape,))

x_numpy (3, 10, 28) y_numpy (3, 10)

Evaluation Function

[7]

def func_eval(model,data_iter,device):

with torch.no_grad():

n_total,n_correct = 0,0

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

for batch_in,batch_out in data_iter:

y_trgt = batch_out.to(device)

model_pred = model.forward(batch_in.view(-1,28,28).to(device))

_,y_pred = torch.max(model_pred,1)

n_correct += (y_pred==y_trgt).sum().item()

n_total += batch_in.size(0)

val_accr = (n_correct/n_total)

model.train() # back to train mode

return val_accr

print ("Done")

Done

Initial Evaluation

[8]

train_accr = func_eval(R,train_iter,device)

test_accr = func_eval(R,test_iter,device)

print ("train_accr:[%.3f] test_accr:[%.3f]."%(train_accr,test_accr))

train_accr:[0.110] test_accr:[0.121].

Train

[9]

print ("Start training.")

R.train() # to train mode

EPOCHS,print_every = 5,1

for epoch in range(EPOCHS):

loss_val_sum = 0

for batch_in,batch_out in train_iter:

# Forward path

y_pred = R.forward(batch_in.view(-1,28,28).to(device))

loss_out = loss(y_pred,batch_out.to(device))

# Update

optm.zero_grad() # reset gradient

loss_out.backward() # backpropagate

optm.step() # optimizer update

loss_val_sum += loss_out

loss_val_avg = loss_val_sum/len(train_iter)

# Print

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

train_accr = func_eval(R,train_iter,device)

test_accr = func_eval(R,test_iter,device)

print ("epoch:[%d] loss:[%.3f] train_accr:[%.3f] test_accr:[%.3f]."%

(epoch,loss_val_avg,train_accr,test_accr))

print ("Done")

Start training. epoch:[0] loss:[0.658] train_accr:[0.944] test_accr:[0.948]. epoch:[1] loss:[0.149] train_accr:[0.971] test_accr:[0.971]. epoch:[2] loss:[0.091] train_accr:[0.982] test_accr:[0.979]. epoch:[3] loss:[0.066] train_accr:[0.986] test_accr:[0.984]. epoch:[4] loss:[0.050] train_accr:[0.985] test_accr:[0.981]. Done

Test

[10]

n_sample = 25

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():

R.eval() # to evaluation mode

y_pred = R.forward(test_x.view(-1,28,28).type(torch.float).to(device)/255.)

y_pred = y_pred.argmax(axis=1)

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

for idx in range(n_sample):

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

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

plt.axis('off')

plt.title("Pred:%d, Label:%d"%(y_pred[idx],test_y[idx]))

plt.show()

print ("Done")

Done

[DLBasic] Sequential Models - Transformer

Multi-Headed Attention

[1]

import numpy as np

import matplotlib.pyplot as plt

import torch

import torch.nn as nn

import torch.optim as optim

import torch.nn.functional as F

%matplotlib inline

%config InlineBackend.figure_format='retina'

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

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

print ("device:[%s]."%(device))

PyTorch version:[1.7.0+cu101]. device:[cuda:0].

Scaled Dot-Product Attention (SDPA)

Data X∈Rn×dX∈Rn×d where nn is the number data and dd is the data dimension
Query and Key Q,K∈Rn×dKQ,K∈Rn×dK
Value V∈Rn×dVV∈Rn×dV

Attention(Q,K,V)=softmax(QKT√dK)V∈Rn×dVAttention(Q,K,V)=softmax(QKTdK)V∈Rn×dV

[2]

class ScaledDotProductAttention(nn.Module):

def forward(self,Q,K,V,mask=None):

d_K = K.size()[-1] # key dimension

scores = Q.matmul(K.transpose(-2,-1)) / np.sqrt(d_K)

if mask is not None:

scores = scores.masked_fill(mask==0, -1e9)

attention = F.softmax(scores,dim=-1)

out = attention.matmul(V)

return out,attention

# Demo run of scaled dot product attention

SPDA = ScaledDotProductAttention()

n_batch,d_K,d_V = 3,128,256 # d_K(=d_Q) does not necessarily be equal to d_V

n_Q,n_K,n_V = 30,50,50

# Q 벡터 입력갯수와 K 벡터 입력개수가 달라도 된다.

Q = torch.rand(n_batch,n_Q,d_K)

K = torch.rand(n_batch,n_K,d_K)

V = torch.rand(n_batch,n_V,d_V)

out,attention = SPDA.forward(Q,K,V,mask=None)

def sh(x): return str(x.shape)[11:-1]

print ("SDPA: Q%s K%s V%s => out%s attention%s"%

(sh(Q),sh(K),sh(V),sh(out),sh(attention)))

# It supports 'multi-headed' attention

n_batch,n_head,d_K,d_V = 3,5,128,256

n_Q,n_K,n_V = 30,50,50 # n_K and n_V should be the same

Q = torch.rand(n_batch,n_head,n_Q,d_K)

K = torch.rand(n_batch,n_head,n_K,d_K)

V = torch.rand(n_batch,n_head,n_V,d_V)

out,attention = SPDA.forward(Q,K,V,mask=None)

# out: [n_batch x n_head x n_Q x d_V]

# attention: [n_batch x n_head x n_Q x n_K]

def sh(x): return str(x.shape)[11:-1]

print ("(Multi-Headed) SDPA: Q%s K%s V%s => out%s attention%s"%

(sh(Q),sh(K),sh(V),sh(out),sh(attention)))

SDPA: Q[3, 30, 128] K[3, 50, 128] V[3, 50, 256] => out[3, 30, 256] attention[3, 30, 50] (Multi-Headed) SDPA: Q[3, 5, 30, 128] K[3, 5, 50, 128] V[3, 5, 50, 256] => out[3, 5, 30, 256] attention[3, 5, 30, 50]

Multi-Headed Attention (MHA)

headi=Attention(QWQi,KWKi,VWVi)headi=Attention(QWiQ,KWiK,VWiV)

[4]

class MultiHeadedAttention(nn.Module):

def __init__(self,d_feat=128,n_head=5,actv=F.relu,USE_BIAS=True,

dropout_p=0.1,device=None):

"""

:param d_feat: feature dimension

:param n_head: number of heads

:param actv: activation after each linear layer

:param USE_BIAS: whether to use bias

:param dropout_p: dropout rate

:device: which device to use (e.g., cuda:0)

"""

super(MultiHeadedAttention,self).__init__()

if (d_feat%n_head) != 0:

raise ValueError("d_feat(%d) should be divisible by b_head(%d)"%

(d_feat,n_head))

self.d_feat = d_feat

self.n_head = n_head

self.d_head = self.d_feat // self.n_head

self.actv = actv

self.USE_BIAS = USE_BIAS

self.dropout_p = dropout_p # prob. of zeroed

self.lin_Q = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)

self.lin_K = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)

self.lin_V = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)

self.lin_O = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)

self.dropout = nn.Dropout(p=self.dropout_p)

def forward(self,Q,K,V,mask=None):

"""

:param Q: [n_batch, n_Q, d_feat]

:param K: [n_batch, n_K, d_feat]

:param V: [n_batch, n_V, d_feat] <= n_K and n_V must be the same

:param mask:

"""

n_batch = Q.shape[0]

Q_feat = self.lin_Q(Q)

K_feat = self.lin_K(K)

V_feat = self.lin_V(V)

# Q_feat: [n_batch, n_Q, d_feat]

# K_feat: [n_batch, n_K, d_feat]

# V_feat: [n_batch, n_V, d_feat]

# Multi-head split of Q, K, and V (d_feat = n_head*d_head)

Q_split = Q_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0,

2, 1, 3)

K_split = K_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0,

2, 1, 3)

V_split = V_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0,

2, 1, 3)

# Q_split: [n_batch, n_head, n_Q, d_head]

# K_split: [n_batch, n_head, n_K, d_head]

# V_split: [n_batch, n_head, n_V, d_head]

# Multi-Headed Attention

d_K = K.size()[-1] # key dimension

scores = torch.matmul(Q_split,K_split.permute(0,1,3,2)) / np.sqrt(d_K)

if mask is not None:

scores = scores.masked_fill(mask==0,-1e9)

attention = torch.softmax(scores,dim=-1)

x_raw = torch.matmul(self.dropout(attention),V_split) # dropout is NOT

mentioned in the paper

# attention: [n_batch, n_head, n_Q, n_K]

# x_raw: [n_batch, n_head, n_Q, d_head]

# Reshape x

x_rsh1 = x_raw.permute(0,2,1,3).contiguous()

# x_rsh1: [n_batch, n_Q, n_head, d_head]

x_rsh2 = x_rsh1.view(n_batch,-1,self.d_feat)

# x_rsh2: [n_batch, n_Q, d_feat]

# 요 부분이 원래 K개를 원래대로 줄여주는 부분. 인데 concat로 바꿈.

# Linear

x = self.lin_O(x_rsh2)

# x: [n_batch, n_Q, d_feat]

out = {'Q_feat':Q_feat,'K_feat':K_feat,'V_feat':V_feat,

'Q_split':Q_split,'K_split':K_split,'V_split':V_split,

'scores':scores,'attention':attention,

'x_raw':x_raw,'x_rsh1':x_rsh1,'x_rsh2':x_rsh2,'x':x}

return out

# Self-Attention Layer

n_batch = 128

n_src = 32

d_feat = 200

n_head = 5

src = torch.rand(n_batch,n_src,d_feat)

self_attention = MultiHeadedAttention(

d_feat=d_feat,n_head=n_head,actv=F.relu,USE_BIAS=True,dropout_p=0.1,

device=device)

out = self_attention.forward(src,src,src,mask=None)

Q_feat,K_feat,V_feat = out['Q_feat'],out['K_feat'],out['V_feat']

Q_split,K_split,V_split = out['Q_split'],out['K_split'],out['V_split']

scores,attention = out['scores'],out['attention']

x_raw,x_rsh1,x_rsh2,x = out['x_raw'],out['x_rsh1'],out['x_rsh2'],out['x']

# Print out shapes

def sh(_x): return str(_x.shape)[11:-1]

print ("Input src:\t%s \t= [n_batch, n_src, d_feat]"%(sh(src)))

print ()

print ("Q_feat: \t%s \t= [n_batch, n_src, d_feat]"%(sh(Q_feat)))

print ("K_feat: \t%s \t= [n_batch, n_src, d_feat]"%(sh(K_feat)))

print ("V_feat: \t%s \t= [n_batch, n_src, d_feat]"%(sh(V_feat)))

print ()

print ("Q_split: \t%s \t= [n_batch, n_head, n_src, d_head]"%(sh(Q_split)))

print ("K_split: \t%s \t= [n_batch, n_head, n_src, d_head]"%(sh(K_split)))

print ("V_split: \t%s \t= [n_batch, n_head, n_src, d_head]"%(sh(V_split)))

print ()

print ("scores: \t%s \t= [n_batch, n_head, n_src, n_src]"%(sh(scores)))

print ("attention:\t%s \t= [n_batch, n_head, n_src, n_src]"%(sh(attention)))

print ()

print ("x_raw: \t%s \t= [n_batch, n_head, n_src, d_head]"%(sh(x_raw)))

print ("x_rsh1: \t%s \t= [n_batch, n_src, n_head, d_head]"%(sh(x_rsh1)))

print ("x_rsh2: \t%s \t= [n_batch, n_src, d_feat]"%(sh(x_rsh2)))

print ()

print ("Output x: \t%s \t= [n_batch, n_src, d_feat]"%(sh(x)))

Input src: [128, 32, 200] = [n_batch, n_src, d_feat] Q_feat: [128, 32, 200] = [n_batch, n_src, d_feat] K_feat: [128, 32, 200] = [n_batch, n_src, d_feat] V_feat: [128, 32, 200] = [n_batch, n_src, d_feat] Q_split: [128, 5, 32, 40] = [n_batch, n_head, n_src, d_head] K_split: [128, 5, 32, 40] = [n_batch, n_head, n_src, d_head] V_split: [128, 5, 32, 40] = [n_batch, n_head, n_src, d_head] scores: [128, 5, 32, 32] = [n_batch, n_head, n_src, n_src] attention: [128, 5, 32, 32] = [n_batch, n_head, n_src, n_src] x_raw: [128, 5, 32, 40] = [n_batch, n_head, n_src, d_head] x_rsh1: [128, 32, 5, 40] = [n_batch, n_src, n_head, d_head] x_rsh2: [128, 32, 200] = [n_batch, n_src, d_feat] Output x: [128, 32, 200] = [n_batch, n_src, d_feat]

[-]

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

퀴즈/과제

막힌거 없다.

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

피어세션

danse layer 차이가 많이 난게 신기햇음. deconvolution은 뭐 하나. 입력을 찾을려고 하는거니까 미분이랑 하는게 똑같음. 실제 뒤집어지더라.

conv 홀수개인 경우 딱 중앙이 되는데 짝수하면 중앙이 아니라 어딘가 하나로 치울치니까 잘 안쓴다.

최근 cnn. alexnet은 gpu 2개 썼다. googlenet inception block을 사용했다. 입력 들어오면 2갈래로 나눠서 한쪽에서 훈련시키고 후에 합친다. resnet이 56 26. 더 깊게했는데도 안되는 걸 x입력변수를 마지막에 한번 더 더해줘서 개선시켰다.

RNN은 연속적으로 흘러가는 데이터를 학습시키는 거다. sequence 데이터가 단순히 나열한 건줄 알았는데 앞이랑 연관이 되어있는 거더라. 사진과 달리 영상은 시간에 따라 이미지가 계속 변하는 형태니까 sequence 데이터에 대해 생각해봤고 이걸 다루는게 RNN이다. RNN 특이한 부분이 입력해서 출력으로 나온걸 다시 입력으로. 이미 출력한 건 과거가 된다. 기울기 소실. pi로 시작하는 항이 sequence 길이가 길어지면 불안정해진다는데 왜 불안정해지는지는 이게 1보다 크면 gradient 값이 커지게 되고 0이면 0으로 수렴 되니까 불안정해진다. 해결책이 BPTT. activation이 reLU로 쓰인 이유가 혹시 이거때문인지.

LSTM. gate들. 특이했다. 단순히 분별로 끝나는게 아니라 어떻게 할지 결정하는 거라. tranformer가 매우 어렵다고 해서 걱정이다.

segmentation 이 궁금하다 알고싶다. 경량화가 되고 파라미터 수 준거. 자꾸 rcnn 나오는거 보면 트렌드가 빨리 바뀐다. 최근에는 하드웨어 장비들이 좋아져서 속도보다 성능을 우선시한다. 하지만 경량화도 중요하구나. LSTM도 어렵게 말하는것 같아서 작년에 따로 배웠던 걸로 알아야 겠다.

강의가 너무 어려워서 예전에 배웠던 모두의 딥러닝에서 배운걸 바탕으로 이해했다. 파라미터 수를 줄이는게 큰 의미를 갖는구나. segmentation. 은 이해를 하겠는데 detection는 per box로 해서 box 내에 차지하는 걸 만들고 다른곳에선 grid로 만들어서 하는것 같더라. boundary 부분 설명 자세히 해줬었으면.. 엄청 큰거랑 미생물 등. 비행기도 멀리서 찍으면 작을거고 미생물도 가까이에선 클텐데 어떻게 박스 크기를 정하는건지. fully connected layer.

손실보단 이용한걸로 생각하면 될 것 같다. 압축이 정보를 좀 더 효율적으로 저장한다. 버려지는 정보들은 어차피 쓸모없는 거였다.

챗봇이라면 NLP 가 중요하다. 구조가 중요하고. 캠프 NLP수업이 부족하니까. cs224 수업 들으면서 천천히 구현해봐라. 자연어처리 데이터셋은 많으니까.

https://littlefoxdiary.tistory.com/42

SK 계열사마다 인재상이 다름. cnc는 실무였던듯.

롯데는 인재상 중요.

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

후기

막막하다.

transformer 가 이론으로 배운거랑 코드랑 너무 달라서 못따라가는게 거기다 차원 갯수를 이해하라고 한다. 어떻게 할지 모르겠다. 주말에 이것만 팔까.