빅데이터 분석 (14주차) 12월16일
순환신경망
딥러닝 공부 추천 교재
- 한국어: 기계학습(오일석)(한빛아카데미)
- 원서: 심층학습(이안굿펠로우) 번역본보다는 원서로..
(-) 표시는 교수님 의견..!
Pytorch and Tensorflow - 컴퓨터 잘하는 사람들, 전문가용
- 장점: 밑바닥부터 구현이 가능하다는 장점, 그래서 어떠한 형태의 알고리즘이라도 구현가능
- 단점: 최종 아웃푹까지 만드는 코딩이 힘듦
- TR / TEST 분리, 배치, GPU, Dropout 등 귀찮은 작업이 있음
- 내가 할 줄 알아도 하기 싫음
Fastai and Keras - 컴퓨터에 익숙하지 않지만 딥러닝을 할 필요가 있는 사람들, 준전문가용
- 장점: 사람들이 쓰기 쉽게 구성되어 있음
- 단점: 지원하는 어플리케이션이 제한되어 있음
Tensorflow
- 산업체에서 많이 쓴다.
- 점유율이 Pytorch보다 앞서고 있다.
- 쓰기 어렵다. 구현방식이 별로이다. (-)
- Google이 서포트한다는 점에서 장점이 있음
- Google이 지원하니까 Tensorflow의 여러 단점들이 하나씩 극복되지 않을까? 하는 기대가 있음 (-)
Pytorch
- 학계에서 많이 쓴다.
- 컴퓨터 공학/통계/산업공학 의외의 다른 정공의 전문가들(=교수님들)이 선호 (-)
- 쓰기가 쉽고 코드 가독성이 높다. 즉, 깔끔하다. (-)
- 요즘 대세, 예제코드 자체가 Tensorflow를 압도하는 느낌 (-)
- Meta(구 facebook)에서 지원, Google만큼의 안전성은 없음 (-)
Keras
- 과거에는 Tensorflow, Pytorch와 어깨를 나란히. 지금은 Tensorflow에 소속되어 있음
- 지금은 Tensorflow에 소속되어 있음
- Google에서 공식 지원
- 현재는 Tensorflow <-> Keras 간의 부드러운 연동이 부족한 느낌 (-)
- 공식문서가 매우 잘 정리되어 있음
Fastai
- Meta(구 facebook)에서 공식 지원하지 않음
- 공식 문서가 잘 정리되지 않음
- 적용되는 어플리케이션의 수가 Keras보다 적다.
- 파이토치와 연동이 부드러움, 그래서 코드를 뜯어보면서 공부하기 좋다. (-)
종합
- Tensorflow + Keras / Pytorch + Fastai 중 하나는 반드시 할 줄 알아야 함,
- 둘 중에서는 Pytorch + Fastai가 좋아보이기도 하다! 가정일뿐
- 4개를 독립적으로 보면 Pytorch(연구목적), Keras(빠르개)가 좋다.
김 교수는 “인공지능은 사람보다 훌륭한 강인공지능과 사람보다 못하지만 사람에게 도움이 되는 약인공지능으로 나눌 수 있다”며 “90년대 후반부터 부활한 인공지능은 기계학습의 발전, 데이터로부터의 지식 추출, 빠른 컴퓨터와 다양한 데이터로 새로운 지식을 창출할 수 있는 방향으로 발전했다”고 설명했다. 또 “사람들은 지식의 오류를 인정하는 약인공지능으로 갔고 약인공지능은 확률, 통계 이론을 중심으로 발전하고 있다”고 덧붙였다. 강인공지능은 영화 터미네이터, 아이로봇에 나오는 로봇처럼 사람의 능력을 뛰어넘는 인공지능을 의미한다. 사람보다 강한 체력과 지능으로 인간이 못하는 일을 척척 해내는 인공지능이다. 반면 약인공지능은 바이센티니얼맨이나 A.I.에 나오는 로봇으로 감성 등 인간 고유의 특성을 넘을 수 없고 오류가 나기도 하지만 뛰어난 연산능력으로 사람의 업무에 도움을 주는 인공지능이다. 인공지능 초기에는 강인공지능이 대세를 이뤘다. 튜링테스트를 시작으로 초기의 자연어 처리 기능이 등장했지만 강인공지능은 커진 기대감을 충족시키지 못하고 큰 실망감을 안기며 사라졌다. 김 교수는 “70년대 중반부터 과학기술 투자 펀드가 인공지능 연구 지원을 끊었는데 이유는 결과물이 없었기 때문”이라고 설명했다.
대략 이렇게 설명.
- 약인공지능: 우리가 수업시간에 배운 AI
- 강인공지능: 우리가 영화에서 보던 AI
Timeline
- 2012년 힌튼 + 알렉스 우승
- 2016년 알파고 우승 3월
- 2016년 김용대교수님 6월
- ..
- 2020년 여름, GPT-3
GPT-3: AGI의 등장.
- 소설 쓰는 AI
- 작곡하는 AI
- github compilot 코드를 이어서 자동으로 짜줌
- GPT3를 기점으로 언어모델의 발전이 눈부심 $\to$ AGI의 출현이라 말하는 사람도 있음
- 최근 뜨고 있는 모델
from fastai.text.all import *
import numpy as np
path = untar_data(URLs.IMDB)
path
files = get_text_files(path)
files
- files: path의 모든 하위폴더에 존재하는 text파일들을 목록화하여 저장한것
is_lm=False
가 default고 텍스트 입력하면 긍정인지 부정인지 맞추는것
is_lm=True
생성하는 모형에 관심있으니까.
dls = DataBlock(
blocks=TextBlock.from_folder(path,is_lm=True),
get_items=get_text_files, splitter=RandomSplitter(0.1)
).dataloaders(path,bs=128,seq_len=80)
- seq_len의 길이에 따라 나타남,
- is_lm(언어모델) false로 놓으면 text만 나타나
dls.show_batch()
- xxbox: 새로운 텍스트의 시작
- xxmaj: 다음단어가 대문자임로 시작함을 의미함 (모든단어는 기본적으로 소문자로 생각함)
lrnr = language_model_learner(dls,AWD_LSTM,metrics=accuracy).to_fp16()
to_fp16()
- 계산을 대충하는 대신,, 가볍게 만드는..
lrnr.fit_one_cycle(5)
lrnr.predict('I liked this movie because',40)
- 말이 안되는게 있긴 하겠지만 그럴듯해보임
- 실행할때마다 달라
간단한 예제를 통한 이해
text = 'h e l l o '*100
text
tokens = text.split(' ')[:-1]
tokens[:10]
- 바로직전의 문자로 다음문자를 맞춰보자
- hello니까, h $\to$ e, e$\to$ l, l $\to$ l/o (?), o $\to$ h, ...
- l 다음에 올 문자가 조금 애매하다.
- 마치 아래의 표에서 $X \to y$인 맵핑을 알아차려 $X$를 보고 $y$를 예측하듯이
| X | y |
|---|---|
| 1 | 2 |
| 2 | 4 |
| 3 | 6 |
| 1 | 2 |
| 2 | 4 |
| 3 | 6 |
| 1 | 2 |
| 2 | 4 |
| ... | ... |
아래의 규칙을 알아차리는 것이 목표이다.
| X | y |
|---|---|
| h | e |
| e | l |
| l | l/o |
| o | h |
| h | e |
| ... | ... |
- X,y를 설정하자.
len(tokens)
X= tokens[:(len(tokens)-1)]
y= tokens[1:]
x다음 y가 이어지는 알파벳 오도록 설정
X[0],y[0]
X[1],y[1]
print(X[:10])
print(y[:10])
- 이제 문자를 숫자로 바꾸어서 컴퓨터가 이해할수 있는 형태, 즉 학습가능한 형태로 만들자.
dic = {'h':0, 'e':1, 'l':2, 'o':3}
dic
dic['h'],dic['e'],dic['l'],dic['o']
nums = [dic[i] for i in tokens]
tokens[:10], nums[:10]
- (맵핑방식1) 아래와 같이 문자와 숫자를 맵핑하였다.
| 문자(tokens) | 숫자(nums) |
|---|---|
| 'h' | 0 |
| 'e' | 1 |
| 'l' | 2 |
| 'l' | 2 |
| 'o' | 3 |
| 'h' | 0 |
| 'e' | 1 |
| 'l' | 2 |
| 'l' | 2 |
| 'o' | 3 |
| ... | ... |
- (맵핑방식2) 위의 방식보다 아래의 방식이 더 의미상 좋다. 위의 방식대로 맵핑하면하면 의미가 e=1, l=2가 되는데 그렇다고 해서 l이 e보다 2배 강한 입력을 의미하는 것은 아니잖음?
| 문자(tokens) | 숫자(nums) |
|---|---|
| 'h' | 1,0,0,0 |
| 'e' | 0,1,0,0 |
| 'l' | 0,0,1,0 |
| 'l' | 0,0,1,0 |
| 'o' | 0,0,0,1 |
| 'h' | 1,0,0,0 |
| 'e' | 0,1,0,0 |
| 'l' | 0,0,1,0 |
| 'l' | 0,0,1,0 |
| 'o' | 0,0,0,1 |
| ... | ... |
- 맵핑방식2로 처리하고 싶은데, 데이터 전처리 하기가 너무 힘들것 같다.
- 그런데 이러한것은 빈번하게 일어나는 상황
- 누군가가 구해놓지 않았을까?
- torch.nn.Embedding
- 맵핑방식1의 구현
_x = torch.tensor([[0.0],[1.0],[2.0],[2.0],[3.0],[0.0],[1.0],[2.0],[2.0],[3.0]])
_x
column으로 만들기 위해 각각을 []에 넣어줌
_l1 = torch.nn.Linear(in_features=1, out_features=20, bias=False)
_l1(_x).shape
_l1(_x)
- 입력: (10,1)
- 출력: (10,20)
- 맵핑방식2의 구현
e1= torch.nn.Embedding(num_embeddings=4, embedding_dim=20)
_x = torch.tensor([0,1,2,2,3,0,1,2,2,3])
_x
e1(_x)
- 입력 (10,1)
- 출력 (10,20)
- torch.nn.Linear(), torch.nn.Embedding() 의 차이가 없어보인다? $\to$ 파라메터를 조사하면 차이가 있다
len(list(_l1.parameters())[0])
list(e1.parameters())[0].shape
- 결국에는 맵핑방식1의 경우 아래와 같이 이해할 수 있고
- ${\bf X}$: (10,1)
- ${\bf W}$: (1,20)
- ${\bf XW}$: (10,20)
- 맵핑방식2의 경우 아래와 같이 이해가능하다.
- ${\bf X}$: (10,1)
- $\tilde{\bf X}$: (10,4)
- ${\bf W}$: (4,20)
- $\tilde{\bf X}{\bf W}$: (10,20)
여기서 4는 (0,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1)을 의미함
- 결국 우리가 맵핑방식2처럼 구현하고 싶다고 해도, 입력은 아래와 같이 넣어도 무방하다. 이후에는 파이토치의 torch.nn.Embedding()이 알아서 해결해준다.
_x
- 이제 숫자화된 자료 nums를 이용하여 다시 X,y를 선언하자.
X = torch.tensor(nums[:499])
y = torch.tensor(nums[1:])
X[0],y[0]
위에서는 h,e였지
X[1],y[1]
위에서는 e,l이었지
- 간단한 네트워크를 설계하자.
e1=torch.nn.Embedding(num_embeddings=4, embedding_dim=20)
l1=torch.nn.Linear(in_features=20,out_features=20)
a1=torch.nn.ReLU()
l2=torch.nn.Linear(in_features=20,out_features=4)
a2=torch.nn.Softmax()
X.shape, e1(X).shape
e1(X).shape, a1(l1(e1(X))).shape
a1(l1(e1(X))).shape, l2(a1(l1(e1(X)))).shape
a2(l2(a1(l1(e1(X))))).shape
- $X$의 차원이 정확하게 명시되지 않아서 대충 컴퓨터가 알아서 계산했다라는 뜻의 워닝
- warning이 떠도 맞게 실행되었나 확인하기 위해 softmax를 수동으로 직접 계산해봄
l2(a1(l1(e1(X))))[0]
np.exp(0.2303)/(np.exp(0.2303)+np.exp( -0.2560)+np.exp(0.0649)+np.exp(-0.1178))
np.exp(-0.2560)/(np.exp(0.2303)+np.exp(-0.2560)+np.exp(0.0649)+np.exp(-0.1178))
np.exp(0.0649)/(np.exp(0.2303)+np.exp( -0.2560)+np.exp(0.0649)+np.exp(-0.1178))
np.exp(-0.1178)/(np.exp(0.2303)+np.exp( -0.2560)+np.exp(0.0649)+np.exp(-0.1178))
a2(l2(a1(l1(e1(X)))))[0]
- 잘 계산된것 같다.
위에서 학습을 잘했다면, e가 (0,1,0,0) 이런식으로 나오게끔 값이 조정될것
- 순전파의 차원변화 요약
torch.Size([499]) # X
torch.Size([499, 20]) # e1이후
torch.Size([499, 20]) # l1이후
torch.Size([499, 20]) # a1이후
torch.Size([499, 4]) # l1이후
torch.Size([499, 4]) # a2이후 = yhatnet = torch.nn.Sequential(
torch.nn.Embedding(num_embeddings=4,embedding_dim=20),
torch.nn.Linear(in_features=20,out_features=20),
torch.nn.ReLU(),
torch.nn.Linear(in_features=20,out_features=4))
#torch.nn.Softmax()
softmax는 손실함수로 빼서 계산할 거야
net(X)
- 손실함수, 옵티마이저
loss_fn = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters())
- 학습
for i in range(1000):
## 1
yhat = net(X)
## 2
loss = loss_fn(yhat,y)
## 3
loss.backward()
## 4
optimizer.step()
optimizer.zero_grad()
X[:7]
net(X)[:7]
- 학습이 잘 되었다.
a2(net(X)[:7])
- 단어수(num_embeddings)가 4에서 바뀔때마다 아래를 반복하여 입력해야할까?
net = torch.nn.Sequential(
torch.nn.Embedding(num_embeddings=4,embedding_dim=20),
torch.nn.Linear(in_features=20,out_features=20),
torch.nn.ReLU(),
torch.nn.Linear(in_features=20,out_features=4))
#torch.nn.Softmax()
- net을 찍어내는 무언가가 있으면 좋겠다. 제가 만들어볼게요!
class BDA(Module):
def __init__(self, num_embeddings):
self.embedding = torch.nn.Embedding(num_embeddings,20)
self.linear1 = torch.nn.Linear(in_features=20,out_features=20)
self.relu = torch.nn.ReLU()
self.linear2 = torch.nn.Linear(in_features=20,out_features=num_embeddings)
def forward(self, X): # net(X)를 계산해주는 방식
u=self.linear1(self.embedding(X))
v=self.relu(u)
return self.linear2(v) # net(X)의 결과
net2 = BDA(4)
net
net2
- net2도 학습하여 net와 동일한 결과가 나오는지 체크해보자.
loss_fn= torch.nn.CrossEntropyLoss()
optimizer2 = torch.optim.Adam(net2.parameters())
for i in range(1000):
## 1
yhat = net2(X)
## 2
loss = loss_fn(yhat,y)
## 3
loss.backward()
## 4
optimizer2.step()
optimizer2.zero_grad()
net2(X)
net(X)
- net2도 잘 학습되었다.
- X,y 를 다시 설정하자.
X = torch.tensor([nums[:498],nums[1:499]]).T
y = torch.tensor(nums[2:])
X[0],y[0] # h,e -> l
X[1],y[1] # e,l -> l
X[2],y[2] # l,l -> o
X[3],y[3] # l,o -> h
- 아키텍처를 대충 스케치하여 보자.
_e1 = torch.nn.Embedding(num_embeddings=4, embedding_dim=20)
X.shape, _e1(X).shape
차원 하나가 늘어나 2가 된 모습
- 이전의 아키텍처는 아래와 같았음
torch.Size([499]) # X
torch.Size([499, 20]) # e1이후
torch.Size([499, 20]) # l1이후
torch.Size([499, 20]) # a1이후
torch.Size([499, 4]) # l1이후
torch.Size([499, 4]) # a2이후 = yhat- 마지막의 차원을 처리하기 애매해진다. $\to$ 순환망을 설계함
X[:,0]
X[:,1]
class BDA2(Module):
def __init__(self, num_embeddings):
self.embedding = torch.nn.Embedding(num_embeddings,20)
self.linear1 = torch.nn.Linear(in_features=20,out_features=20)
self.relu = torch.nn.ReLU()
self.linear2 = torch.nn.Linear(in_features=20,out_features=num_embeddings)
def forward(self, X): # net(X)를 계산해주는 방식
x1=X[:,0] # X의 첫번째 칼럼, y보다 2시점 이전 (x1,x2) -> y // (h,e) --> l
x2=X[:,1] # X의 두번째 칼럼, y보다 1시점 이전
h=self.relu(self.linear1(self.embedding(x1))) # x1 -> x2를 예측하는 네트워크의 일부
h2=self.relu(self.linear1(h+ self.embedding(x2))) # x2 -> y를 예측하는 네트어크의 일부
return self.linear2(h2) # net(X)의 결과
- 결국 최종출력인 self.linear2(h2)는 h와 x2가 담긴 함수이다. 그런데 h는 x1이 담긴 함수이다. 따라서 h2는 x2가 담겨있는 동시에 x1에 대한 정보도 약하게 담겨있다고 볼 수 있음
net3=BDA2(4)
net3
net2
- 구조의 차이는 없지만 순전파의 계산방식이 다르다! (그렇다면 역전파 계산방식도 다르겠죠?)
- 다시 학습해보자.
loss_fn = torch.nn.CrossEntropyLoss()
optimizer3= torch. optim.Adam(net3.parameters())
for i in range(1000):
## 1
yhat = net3(X)
## 2
loss = loss_fn(yhat,y)
## 3
loss.backward()
## 4
optimizer3.step()
optimizer3.zero_grad()
X[:5]
net3(X)[:5]
- h,e $\to$ l
- e,l $\to$ l
- l,l $\to$ o
- l,o $\to$ h
- o,h $\to$ e
- 학습이 잘 되었다.
- 기사를 대신 써준다던가.
- 축구는 전반은 어떘다, 후반은 어땠다 등 넣어주면 y를 출력해내는 게 어렵지 않음
- 하지만 파라메터 많이 필요하고...
- 작년부터 다시 뜨기 시작함..
- 시계열이랑 RNN이랑 비슷