(7-8주차) 10월26일 10월28일
Pytorch CNN (MNIST 3/7), CAM
- 강의영상
- import
- data
- 1. 지난시간까지의 모형 (직접네트워크설계, pytorch)
- 2. 드랍이웃, 배치추가 (직접네트워크설계, pytorch+fastai)
- 3. resnet34 (기존의 네트워크 사용, 순수 fastai)
- 모형을 뜯어보는 방법 (lrnr1.model)
- lrnr2.model 분석
- 딥러닝 연구의 네가지 축
- 설명가능한 CNN모형
- CAM: observation을 1개로 고정하고 net2에서 layer의 순서를 바꿔서 시각화
- 숙제
- (1/10) 드랍아웃, 배치추가 (1)
- (2/10) 드랍아웃, 배치추가 (2)
- (3/10) resnet34
- (4/10) 모형을 뜯어보는 방법 (직접만든모델)
- (5/10) resnet34 의 구조 (1)
- (6/10) resnet34 의 구조 (2)
- (7/10) 의 형태에 따라 달라지는 오차항가정/활성화함수/손실함수, 딥러닝의 연구의 4가지 축, 설명가능한 딥러닝의 필요성
- (8/10) CAM (1)
- (9/10) CAM (2)
- (10/10) CAM (3)
import torch
from fastai.vision.all import *
import graphviz
def gv(s): return graphviz.Source('digraph G{ rankdir="LR"'+ s + ';}')
- download data
path = untar_data(URLs.MNIST_SAMPLE)
path.ls()
- list
threes=(path/'train'/'3').ls()
sevens=(path/'train'/'7').ls()
- list image
Image.open(threes[4])
- image tensor
tensor(Image.open(threes[4]))
- 여기에서 tensor는 파이토치가 아니라 fastai에서 구현한 함수임
- 여러개의 리스트를 모두 텐서로 바꿔보자.
seven_tensor = torch.stack([tensor(Image.open(i)) for i in sevens]).float()/255
three_tensor = torch.stack([tensor(Image.open(i)) for i in threes]).float()/255
- 와 를 만들자.
seven_tensor.shape, three_tensor.shape
y=torch.tensor([0.0]*6265+ [1.0]*6131).reshape(12396,1)
X=torch.vstack([seven_tensor,three_tensor]).reshape(12396,-1)
X.shape, y.shape
X=X.reshape(12396,1,28,28)
X.shape
c1=torch.nn.Conv2d(1,16,5) # 입력채널=1 (흑백이므로), 출력채널=16, 윈도우크기5
X.shape, c1(X).shape
m1=torch.nn.MaxPool2d(2)
X.shape,c1(X).shape,m1(c1(X)).shape
a1=torch.nn.ReLU()
X.shape,c1(X).shape, m1(c1(X)).shape, a1(m1(c1(X))).shape
class Flatten(torch.nn.Module):
def forward(self,x):
return x.reshape(12396,-1)
flatten=Flatten()
X.shape,c1(X).shape, m1(c1(X)).shape, a1(m1(c1(X))).shape, flatten(a1(m1(c1(X)))).shape
l1=torch.nn.Linear(in_features=2304,out_features=1)
X.shape,\
c1(X).shape, \
m1(c1(X)).shape, \
a1(m1(c1(X))).shape, \
flatten(a1(m1(c1(X)))).shape, \
l1(flatten(a1(m1(c1(X))))).shape
plt.plot(l1(flatten(a1(m1(c1(X))))).data)
net = nn.Sequential(c1,m1,a1,flatten,l1)
## 마지막의 sigmoid는 생략한다. torch.nn..BCEWithLogitsLoss()에 내장되어 있을것이므로
- 손실함수와 옵티마이저 정의
loss_fn=torch.nn.BCEWithLogitsLoss()
optimizer= torch.optim.Adam(net.parameters())
- step1~4
for epoc in range(200):
## 1
yhat=net(X)
## 2
loss=loss_fn(yhat,y)
## 3
loss.backward()
## 4
optimizer.step()
net.zero_grad()
a2= torch.nn.Sigmoid()
plt.plot(y)
plt.plot(a2(yhat.data),'.')
ypred=a2(yhat.data)>0.5
sum(ypred==y)/12396
ds=torch.utils.data.TensorDataset(X,y)
ds.tensors[0].shape
ds1,ds2 = torch.utils.data.random_split(ds,[10000,2396])
dl1 = torch.utils.data.DataLoader(ds1,batch_size=500)
dl2 = torch.utils.data.DataLoader(ds2,batch_size=2396)
dls=DataLoaders(dl1,dl2)
class Flatten(torch.nn.Module):
def forward(self,x):
return x.reshape(x.shape[0],-1)
net=torch.nn.Sequential(
torch.nn.Conv2d(1,16,5),
torch.nn.MaxPool2d(2),
torch.nn.ReLU(),
torch.nn.Dropout2d(),
Flatten(),
torch.nn.Linear(2304,1))
loss_fn=torch.nn.BCEWithLogitsLoss()
#optimizer= torch.optim.Adam(net.parameters())
lrnr1 = Learner(dls,net,opt_func=Adam,loss_func=loss_fn)
lrnr1.fit(10)
- 결과를 시각화하면 아래와 같다.
plt.plot(a2(net(X.to("cuda:0")).to("cpu").data),'.')
- 빠르고 적합결과도 좋음
- 데이터로부터 새로운 데이터로더스를 만들고 이를 dls2라고 하자.
path=untar_data(URLs.MNIST_SAMPLE)
path
dls2=ImageDataLoaders.from_folder(
path,
train='train',
valid_pct=0.2)
- 러너오브젝트를 생성하고 학습하자.
lrnr2=cnn_learner(dls2,resnet34,metrics=error_rate)
lrnr2.fine_tune(1)
- 결과관찰
lrnr2.show_results()
- 우선 방법2로 돌아가자.
net(X.to("cuda:0"))
- 네트워크 구조
net
- 층별변환과정
print(X.shape, '--> input image')
print(net[0](X.to("cuda:0")).shape, '--> 2dConv')
print(net[1](net[0](X.to("cuda:0"))).shape, '--> MaxPool2d')
print(net[2](net[1](net[0](X.to("cuda:0")))).shape, '--> ReLU')
print(net[3](net[2](net[1](net[0](X.to("cuda:0"))))).shape, '--> Dropout2d')
print(net[4](net[3](net[2](net[1](net[0](X.to("cuda:0")))))).shape, '--> Flatten')
print(net[5](net[4](net[3](net[2](net[1](net[0](X.to("cuda:0"))))))).shape, '--> Linear')
- 최종결과
net[5](net[4](net[3](net[2](net[1](net[0](X.to("cuda:0")))))))
net(X.to("cuda:0"))
- lrnr1자체를 활용해도 층별변환과정을 추적할수 있음. (lrnr1.model = net 임을 이용)
lrnr1.model
lrnr1.model[0]
lrnr1.model(X.to("cuda:0"))
print(X.shape, '--> input image')
print(lrnr1.model[0](X.to("cuda:0")).shape, '--> 2dConv')
print(lrnr1.model[1](lrnr1.model[0](X.to("cuda:0"))).shape, '--> MaxPool2d')
print(lrnr1.model[2](lrnr1.model[1](lrnr1.model[0](X.to("cuda:0")))).shape, '--> ReLU')
print(lrnr1.model[3](lrnr1.model[2](lrnr1.model[1](lrnr1.model[0](X.to("cuda:0"))))).shape, '--> Dropout2d')
print(lrnr1.model[4](lrnr1.model[3](lrnr1.model[2](lrnr1.model[1](lrnr1.model[0](X.to("cuda:0")))))).shape, '--> Flatten')
print(lrnr1.model[5](lrnr1.model[4](lrnr1.model[3](lrnr1.model[2](lrnr1.model[1](lrnr1.model[0](X.to("cuda:0"))))))).shape, '--> Linear')
- 정리: 모형은 항상 아래와 같이 2d-part 와 1d-part로 나누어진다.
torch.Size([12396, 1, 28, 28]) --> input image
torch.Size([12396, 16, 24, 24]) --> 2dConv
torch.Size([12396, 16, 12, 12]) --> MaxPool2d
torch.Size([12396, 16, 12, 12]) --> ReLU
torch.Size([12396, 16, 12, 12]) --> Dropout2d
===============================================================
torch.Size([12396, 2304]) --> Flatten
torch.Size([12396, 1]) --> Linear- 2d-part:
- 2d선형변환: nn.torch.nn.Conv2d()
- 2d비선형변환: torch.nn.MaxPool2d(), torch.nn.ReLU()
- 1d-part:
- 1d선형변환: torch.nn.Linear()
- 1d비선형변환: torch.nn.ReLU()
_net1=torch.nn.Sequential(
net[0],
net[1],
net[2],
net[3])
_net2=torch.nn.Sequential(
net[4],
net[5])
_net1
_net2
_net=torch.nn.Sequential(_net1,_net2)
_net[1](_net[0](X.to('cuda:0')))
- 아래의 모형은 현재 가장 성능이 좋은 모형(state of the art)중 하나인 resnet이다.
lrnr2.model
- 특징
- 2d-part: 입력채널이3이다, Conv2d에 padding/stride의 옵션이 있다, 드랍아웃이 없다, 배치정규화가 있다.
- 1d-part: 배치정규화가 있다, 출력의 차원이 2이다.
DLS, Networks
- 네트워크의 형태에 따라서 dls의 형태도 다르게 만들어야 한다.
- MLP모형: 입력이 , 첫 네트워크의 형태가 인 torch.nn.Linear()
- CNN모형: 입력이 , 첫 네트워크의 형태가 인 torch.nn.Conv2d()
- Resnet34: 입력이 , 첫 네트워크의 형태가
참고
| 분포가정 | 마지막층의 활성화함수 | 손실함수(파이토치) | |
|---|---|---|---|
| 3.45, 4.43, ... (연속형) | 정규분포 | Linear | MSEloss |
| 0 or 1 | 이항분포(베르누이) | Sigmoid | BCEloss |
| [0,0,1], [0,1,0], [1,0,0] | 다항분포 | Softmax | CrossEntropyLoss |
(1) 아키텍처
- 한 영역의 전문적인 지식이 필요한 것이 아닌것 같다.
- 끈기, 약간의 운, 직관, 좋은컴퓨터..
(2) 손실함수
- 통계적지식필요 // 기존의 손실함수를 변형하는 형태 (패널티텀활용)
(3) 미분계산
- 병렬처리등에 대한 지식 필요
(4) 옵티마이저
- 최적화에 대한 이론적 토대 필요
- 딥러닝 이전까지의 아키텍처에 대한 연구
- 파라메트릭 모형: 전문가
- 넌파라메트릭 모형: 전문가
- 딥러닝: 상대적으로 비전문가
- 특징: 비전문가도 만들수 있다 + 블랙박스 (내부연산을 뜯어볼 수는 있지만 우리가 해석하기 어려움)
- 설명가능한 딥러닝에 대한 요구 (XAI)
- 현재까지의 모형
- 1단계: 2d선형변환 2d비선형변환
- 2단계: Flatten MLP
- lrnr1(제가만들었던 모형)의 모형을 다시 복습
lrnr1.model
net1=torch.nn.Sequential(
lrnr1.model[0],
lrnr1.model[1],
lrnr1.model[2],
lrnr1.model[3])
net1(X.to('cuda:0')).shape
- 1단계까지의 출력결과를 시각화
fig, axs = plt.subplots(4,4)
k=0
for i in range(4):
for j in range(4):
axs[i,j].imshow(net1(X.to("cuda:0"))[0][k].to("cpu").data)
k=k+1
fig.set_figheight(8)
fig.set_figwidth(8)
fig.tight_layout()
lrnr1.model
- 계획
- 변경전net2:
- 변경후net2:
- gap: 1212 픽셀을 평균내서 하나의 값으로 대표하자 (왜?)
ap=torch.nn.AdaptiveAvgPool2d(output_size=1)
ap(net1(X.to("cuda:0"))).shape
--
보충학습:ap는 그냥 평균
torch.tensor([[0.1,0.2],[0.3,0.4]])
ap(torch.tensor([[0.1,0.2],[0.3,0.4]]))
--
- flatten
flatten(ap(net1(X.to("cuda:0")))).shape
- linear
_l1=torch.nn.Linear(16,1,bias=False)
_l1.to("cuda:0")
_l1(flatten(ap(net1(X.to("cuda:0"))))).shape
- 이걸 net2로 구성하자. (net1,net2)를 묶어서 하나의 새로운 네트워크를 만들자.
net2=torch.nn.Sequential(
torch.nn.AdaptiveAvgPool2d(1),
Flatten(),
torch.nn.Linear(16,1,bias=False))
net=torch.nn.Sequential(net1,net2)
net
- 수정된 네트워크로 lrnr3을 만들고 재학습
ds=torch.utils.data.TensorDataset(X,y)
ds1,ds2=torch.utils.data.random_split(ds,[10000,2396])
dl1=torch.utils.data.DataLoader(ds1,batch_size=1000)
dl2=torch.utils.data.DataLoader(ds2,batch_size=2396)
dls=DataLoaders(dl1,dl2)
lrnr3=Learner(dls,net,opt_func=Adam,loss_func=loss_fn,lr=0.1)
lrnr3.fit(10)
- 계획
- 변경전net2:
- 변경후net2:
- CAM:
- 준비과정1: 시각화할 샘플을 하나 준비하자.
x=X[100]
X.shape,x.shape
- 차원이 다르므로 나중에 네트워크에 넣을때 문제가 생길 수 있음 차원을 맞춰주자
x=x.reshape(1,1,28,28)
plt.imshow(x.squeeze())
- 준비과정2: 계산과 시각화를 위해서 각 네트워크를 cpu로 옮기자. (fastai로 학습한 직후라 GPU에 있음)
net1.to('cpu')
net2.to('cpu')
- forward확인: 이 값을 기억하자.
net2(net1(x)) ## 음수이므로 class=7 이라고 CNN이 판단
- net2를 수정하고 forward값 확인
net2
- net2에서 Linear와 AdaptiveAvgPool2d의 적용순서를 바꿔줌
차원확인
net1(x).squeeze().shape
net2[2].weight.squeeze().shape
Linear(in_features=16, out_features=1, bias=False) 를 적용: 16 (16,12,12) (12,12)
net2[2].weight.squeeze() @ net1(x).squeeze()
- 실패..
camimg=torch.einsum('i,ijk -> jk',net2[2].weight.squeeze(), net1(x).squeeze())
camimg.shape
- 성공
AdaptiveAvgPool2d(output_size=1) 를 적용
ap(camimg)
!!!! 똑같다?
- 아래의 값이 같다.
net2(net1(x)),ap(camimg)
- 왜냐하면 ap와 선형변환 모두 linear이므로 순서를 바꿔도 상관없음
- 아래와 결국 같은 이치
_x= np.array([1,2,3,4])
_x
np.mean(_x*2+1)
2*np.mean(_x)+1
- 이제 camimg 에 관심을 가져보자.
camimg
ap(camimg), torch.mean(camimg)
- 이미지의 값은 대부분0이지만 궁극적으로는 평균을 내서 음수의 값이 나와야 한다.
- 결국 특정픽셀에서 큰 음의 값이 나오기 떄문에 궁극적으로는 평균이 음수가 된다.
- 평균이 음수이다. 이미지가 의미하는것이 7이다.
- 특정픽셀이 큰 음수값을 가진다. 그 픽셀에서 이미지가 7임을 뚜렷하게 알 수 있다.
- 그 특정픽셀이 어딘가?
plt.imshow(camimg.data)
- 초록색으로 표현된 부분은 CNN모형이 이 숫자를 7이라고 생각한 근거가 된다.
- 원래의 이미지와 비교
plt.imshow(x.squeeze())
- 두 이미지를 겹쳐서 그리면 멋진 그림이 될 것 같다.
step1: 원래이미지를 흑백으로 그리자.
plt.imshow(x.squeeze(),cmap='gray',alpha=0.5)
- step2: 원래이미지는 (28,28)인데 camimg는 (12,12)픽셀 camimg의 픽셀을 늘리자.
plt.imshow(camimg.data,alpha=0.5, extent=(0,27,27,0),interpolation='bilinear',cmap='magma')
- step3: 합치자.
plt.imshow(x.squeeze(),cmap='gray',alpha=0.5)
plt.imshow(camimg.data,alpha=0.5, extent=(0,27,27,0),interpolation='bilinear',cmap='magma')
- 숫자3이 그려진 이미지를 observation으로 선택하고 위와 같이 cam을 이용하여 시각화하라.