※ 본 내용은 stanford에서 제공하는 cs231n 강의, 강의자료를 바탕으로 작성하였습니다.
Lecture 16에서는 lecture 13에서 간단하게 다뤘던 adversarial examples에 대해 다루고 있다.
Noise로 보이는 필터를 중심으로 왼쪽과 오른쪽의 판다 이미지는 사람이 보기엔 둘 다 판다 이미지이고, filter를 더한 것조차 알아보기 어렵다.
그러나 머신러닝 모델은 좌측의 이미지를 60% 확률로 판다로 예측하고, filter가 더해진 오른쪽의 판다 이미지는 99% 확률로 긴팔 원숭이로 예측한다.
이러한 이미지들을 Adversarial Examples라고 하고, 이러한 이미지들은 model을 속일 수 있다.
그리고 이러한 adversarial examples는 매우 쉽게 생성할 수 있다.
먼저 이러한 문제는 왜 발생할까?
- From overfitting or from underfitting?
처음엔 연구자들은 이러한 현상이 overfitting에 의한 것이라고 생각했다.
Model의 classification boundary가 너무 복잡하고 정교하다 보니 잘못된 boundary가 존재하고, 해당 영역으로 인해 misclassification이 발생한다고 보았다.
그러나 이는 잘못된 생각이었다.
우선, 하나의 adversarial example에 의해 여러 모델이 잘못 동작했고, 심지어 서로 같은 클래스로 misclassification을 수행했다. 따라서 학습 과정에서 model별 boundary가 복잡하기 때문에 생긴 random 오류라고 볼 수 없었다.
즉, 시스템 자체의 문제인 것이었다.
Underfitting
이에 연구자들은 이러한 문제가 오히려 지나치게 linear한 classifier, underfitting에 의한 것이 아닐까 생각하게 되었다.
실제로 deep nets는 부분적인 linear 형태를 지닌다고 밝혀졌다.
Input과 output 사이의 mapping이 piecewise linear한 형태인 것이지, 모델의 parameters와 output은 복잡한 non-linear 형태이다.
따라서 adversarial examples를 생성하는 것은 간단하다.
이미지는 거의 보이지 않지만 plot을 중점적으로 보면, automobile class의 image에 어떠한 direction vector* $ \epsilon$ 값을 더해주며 각 class에 대한 logits를 plot한 결과이다.
여기에서 더해진 direction이 frog class로의 direction이며, logits가 linear하게 변경되는 것을 확인할 수 있다.
FGSM
이러한 direction을 찾는 것은 어렵지 않다. 미분값의 sign을 찾고, gradient ascent algorithm을 이용하면 된다.
CIFAR 10 dataset에 FGSM을 이용해 방향을 찾고, $ \epsilon$ * direction을 더해가며 실험해본 결과이다.
(y축은 direction에 orthogonal한 vector)
각 grid는 서로 다른 test data를 의미하고, 흰색은 맞게 classification한 경우, 색칠된 영역은 다른 class로 prediction한 경우이다.
FGSM을 찾은 방향으로 이동하면 linear한 misclassification boundary가 발생하는 것을 확인할 수 있다.
반면 orthogonal한 방향으로는 발생하지 않는다.
- Problem, Attack
당연히 모델을 속이는 이러한 adversarial examples는 문제가 된다.
대표적으로 RL agent를 생각해보면, 주어진 영상을 보고 행동을 결정하는데 주어진 영상이 adversarial examples라면 잘못된 행동을 결정하게 되는 것이다.
그러나 그러한 경우를 막기위해 model 자체의 parameters를 숨기더라도, 해당 모델을 공격하는 adversarial examples를 생성하는 것은 어렵지 않다.
해당 모델에 대한 미분을 수행할 수 없더라도(FGSM 적용 불가), 그 모델이 어떻게 classification을 수행하는지만 mimick 하도록 학습한 모델(FGSM 적용 가능)을 이용해 찾은 adversarial examples는 traget model도 속일 확률이 매우 크다.
특히 여기에 ensembles 알고리즘까지 적용하여 여러 모델을 한 번에 mimicking하면 그 확률은 매우 커진다.
- Defense
먼저 아쉽게도 대부분의 defense는 성공하지 않았다고 한다.
(※ 17년도 강의이므로 현재는 더 다양한 defense 기법들이 나왔을 것으로 생각됩니다.)
Generative Modeling
데이터의 분포를 학습하는 generative modeling도 하나의 방법이 될 수 있다. 이미지가 정상적인 분포를 갖는지 아닌지 검사하는 것이다.
그러나 단순히 이미지에 대한 분포보다는 class를 먼저 예측하고, 해당 class에 대한 inputs의 분포가 더 중요한 것으로 나타나서, 단순한 generative modeling으로는 충분히 방어가 되지 않는다고 한다.
매우 정교하게 설계된 generative modeling이 어느 정도 효과가 있을 것이라고 발표자는 예측하고 있다.
애초에 adversarial examples를 통해 training을 진행하는 것이 그나마 동작하는 방법이다.
그래프를 보면 정상적으로 동작하는 것을 확인할 수 있고, regularization 효과로 인해 약간의 성능 개선도 확인할 수 있다.
(SVM이나 linear regression 같은 linear models는 어차피 그 경계가 linear하기 때문에 adversarial training이 덜 동작한다. 따라서 deep learning이 오히려 더 secure하다고도 볼 수 있다.)
from einops import rearrange
class Embedding(nn.Module) :
def __init__(self, input_size = 32, input_channel = 3, hidden_size = 8*8*3, patch_size = 4) :
super().__init__()
self.patch_size = patch_size
self.hidden_size = hidden_size
self.projection = nn.Linear((patch_size**2)*input_channel, hidden_size, bias = False)
self.cls_token = nn.Parameter(torch.zeros(hidden_size), requires_grad= True)
num_patches = int((input_size / patch_size) ** 2 + 1)
self.positional = nn.Parameter(torch.zeros((num_patches, hidden_size), requires_grad= True))
def forward(self, x) :
x = rearrange(x, 'b c (h p1) (w p2) -> b (h w) (c p1 p2)', p1 = self.patch_size, p2 = self.patch_size)
x = self.projection(x)
batch_size = x.shape[0]
x = torch.concat((self.cls_token.expand(batch_size, 1, self.hidden_size), x), axis = 1)
x = x + self.positional
return x
먼저 CIFAR 10 dataset은 3x32x32 크기로 작기 때문에, patch size와 hidden size 또한 그에 맞춰 작게 설정했습니다.
이미지를 patch로 나누는 과정이 복잡할 것이라고 예상했는데, 'einops'를 사용하면 한 줄로 간단하게 구현할 수 있었습니다.
Einops 동작
Input으로 주어진 images의 shape가 'batch size x channel x H x W'라고 할 때 H와 W를 각각 h, w개의 patch들로 이뤄졌다고 보고, 각각의 batch 별로 h*w 개의 c*p1*p2 크기의 vector로 만들라는 내용의 코드입니다.
Einops 자체가 직관적이라 arange로 표현된 예시와 함께 살펴보시면 이해될 것이고,
자세한 einops의 동작에 대해서는 공식문서나 튜토리얼이 있으니 찾아보면 좋을 것 같습니다.
원하던대로 image의 각 영역(patches)을 vector로 만든 것을 확인할 수 있습니다.
Cls token이나 positional embedding은 nn.Parameter를 통해 구현했고,
cls token의 경우 expand와 concat을 통해, positional embedding의 경우 broadcasting을 통해 더해줍니다.
여기에서도 einop의 rearrange와 torch.einsum을 이용하는데, 먼저 코드는 다음과 같습니다.
# https://github.com/FrancescoSaverioZuppichini/ViT/blob/main/transfomer.md
class MSA(nn.Module) :
def __init__(self, hidden_dim = 8*8*3, num_heads = 6) :
super().__init__()
self.num_heads = num_heads
self.D_h = (hidden_dim / num_heads) ** (1/2)
self.queries = nn.Linear(hidden_dim, hidden_dim)
self.keys = nn.Linear(hidden_dim, hidden_dim)
self.values = nn.Linear(hidden_dim, hidden_dim)
self.softmax = nn.Softmax(dim = 1)
def forward(self, x) :
q = rearrange(self.queries(x), 'b n (h d) -> b h n d', h = self.num_heads)
k = rearrange(self.queries(x), 'b n (h d) -> b h n d', h = self.num_heads)
v = rearrange(self.queries(x), 'b n (h d) -> b h n d', h = self.num_heads)
A = torch.einsum('bhqd, bhkd -> bhqk', q, k)
A = self.softmax(A / self.D_h)
Ax = torch.einsum('bhan, bhnd -> bhad' ,A, v) # b : batch size, h : num_heads, n : num_patches, a : num_patches, d : D_h
return rearrange(Ax, 'b h n d -> b n (h d)')
먼저 query, key, value weights를 nn.Linear layer로 선언하는데, 이번엔 모든 heads의 weights를 하나의 layer로 처리하기 때문에 output의 크기로 D(hidden dim)가 유지됩니다.
즉, 각 헤드별로 Nx$ D_h$, (N x D) x (D x $ D_h$)의 결과를 생성하는 것을 한번에 N x D로 처리합니다.
따라서 forward weight를 거친 결과는 다음과 같게 됩니다.(query 기준, h : # of heads)
따라서 먼저 einops의 rearrange를 통해 shape를 변형해줍니다.
'b n (h d) -> b h n d'로 변환되는 과정은 아래와 같습니다. 각 head별 output으로 분리해줍니다.
(batch size = 2, num patches = 4, hidden_dim = 2, num_heads = 3인 경우의 예시입니다.)
rearrange
이제 einsum을 이용해서 분리된 shape에 맞게 $ QK^T$를 계산해줍니다.
('bhqd, bhkd -> bhqk', q, k)를 수행하게 되면 위와 같이 batch나 head구조는 유지되면서 각 head별로 $QK^T$가 계산됩니다.
사실 einsum을 이번에 처음 접해봐서 정확한 동작은 모르겠지만, ('bhqd, bhkd -> bhqk', q, k)를 수행하게 되면 위와 같이 shape에 맞춰서 k의 값들이 자동으로 transpose된 후 곱해지는 것으로 보입니다.
(Transpose가 이뤄진 후 곱해지는 것은 확실하지 않지만 우선 결과는 그렇게 생각했을 때와 동일합니다.)
그 결과 Batch x # heads x N x N shape의 결과가 나오는 것을 확인할 수 있고, 여기에서 다시 einsum을 이용해서 각 batch, head 별로 $ Av$를 계산해줍니다.(A = softmax($ \frac{QK^T}{\sqrt{D_h}}$))
마찬가지로 batch나 head 별 구조는 유지하면서 NxN 크기의 attention weight와 Nx$D_h$ 크기의 value matrix를 곱해주면 되므로 'bhan, bhnd -> bhad'와 같이 변경되도록 작성해줍니다.
(attention weight를 bhnn이 아니라 bhan으로 표현한 이유는 nn과 같이 하나의 문자로 두개의 차원을 표현하면 안되기 때문입니다.)
그 결과 Batch x # heads x N x $D_h$ 크기의 결과가 나오므로, 마지막으로 다시 rearrange를 사용해서
Batch x N x D(= # heads * $D_h$)의 shape으로 변경시켜줍니다.
rearrange(Ax, 'b h n d -> b n (h d)')와 같이 변경시켜주면 됩니다.
