์๋ก
์ธ๊ณต์ง๋ฅ(Artificial Intelligence) ๋ชจ๋ธ์ด ํ์ค์ ๋์ ๋ ๋์๋ โ๋์ฒด๋กโ ์ ์๋ํ๋ ๊ฒ์ ์คํ๋ ค ์ต์ ์กฐ๊ฑด์ด ๋ฉ๋๋ค. ์คํ๋ ค, ์ฐ๋ฆฌ๊ฐ ํด๋น ๋ชจ๋ธ์ ์ ๋ขฐํ ์ ์๋์ง๊ฐ ์ค์ํด์ง๋๋ค.
์ ๋์ ๊ฐ๊ฑด์ฑ(Adversarial Robustness)์ด๋ โ์ ์์ ์ธ ๊ณต๊ฒฉ์๊ฐ ์ ๋ ฅ์ ํน์ ๋ ธ์ด์ฆ(Noise)๋ฅผ ์ฃผ์์ ๋์๋ ๋ชจ๋ธ์ด ์ ์๋ํ ์ ์๋๊ฐ?โ๋ฅผ ์๋ฏธํฉ๋๋ค. ํ์ฌ ๋ฅ๋ฌ๋(Deep Learning)์ ํฌํจํ ์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ด ์ง๋ฉดํ๊ณ ์๋ ๋ง์ ๊ฒฐ์ ๋ค ์ค ๊ฐ์ฅ ํฐ ๊ฒฐ์ ์ด๊ธฐ๋ ํฉ๋๋ค.
โFantastic Robustness Measures: The Secrets of Robust Generalizationโ [Paper, Repo] ์ ์ธ๊ณต์ง๋ฅ ์ต์ฐ์ ํํ์ธ NeurIPS 2023์์ ๋ฐํ๋ ๋ณธ ์ฐ๊ตฌ์ค์ ๋ ผ๋ฌธ์ด๋ฉฐ, ๋ณธ ๊ธ์์๋ ๊ธฐ๋ณธ์ ์ธ ์ํ๊ณผ ๊ฐ๋จํ ์ฝ๋๋ฅผ ํตํด ์ ๋์ ๊ฐ๊ฑด์ฑ์ ๊ฐ๋ ์ ์์๋ณด๊ณ ์ ํฉ๋๋ค.
์ฌ์ ์ง์
์ ๋์ ์์ ์ ์ ๋์ ๊ณต๊ฒฉ
Source: https://adversarial-ml-tutorial.org/introduction/ [NeurIPS 2018 tutorial, โAdversarial Robustness: Theory and Practiceโ]
์ ๋์ ๊ฐ๊ฑด์ฑ์ ๊ฐ์ฅ ์ ์ดํดํ๋ ๋ฐฉ๋ฒ์ โ์ ๋์ ์์ ๋ฅผ ๋ง๋ค์ด๋ณด๋ ๊ฒโ์ ๋๋ค. ์ ๋์ ์์ (Adversarial Example)์ด๋ ๊ณต๊ฒฉ์๊ฐ ์ ์์ ์ธ ์ ๋ ฅ(Benign Input)์ ์ ์์ ์ธ ๋ ธ์ด์ฆ(Adversarial Noise)๋ฅผ ์ฝ์ ํ ๊ฒ์ ๋๋ค. ์ด ๋ ์ฌ์ฉ๋๋ ๋ ธ์ด์ฆ๋ ์ญ๋(Perturbation)์ด๋ผ๊ณ ๋ ๋ถ๋ ค์ง๋๋ค.
์ฐ์ , PyTorch ๋ด์ ์ฌ์ ํ๋ จ๋ ResNet50 ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์ ์์ ์ธ(Benign) ๋ผ์ง ์ฌ์ง์ ๋ถ๋ฅํด๋ณด๊ฒ ์ต๋๋ค.

(1) ์ฐ์ ์ฌ์ง์ ์ฝ์ด๋ค์ด๊ณ 224x224๋ก ์ฌ์ด์ฆ๋ฅผ ๋ณํํฉ๋๋ค.
from PIL import Image
from torchvision import transforms
# read the image, resize to 224 and convert to PyTorch Tensor
pig_img = Image.open("pig.jpg")
preprocess = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
])
pig_tensor = preprocess(pig_img)[None,:,:,:]
# plot image (note that numpy using HWC whereas Pytorch user CHW, so we need to convert)
plt.imshow(pig_tensor[0].numpy().transpose(1,2,0))
(2) ํฌ๊ธฐ๊ฐ ์กฐ์ ๋ ์ด๋ฏธ์ง์ ์ ๊ทํ(Normalization)์ ๊ฑฐ์น ํ, ํ์ต๋ ResNet50 ๋ชจ๋ธ์ ๋ถ๋ฌ์์ ์ฌ์ง์ ๋ถ๋ฅํด๋ณด๊ฒ ์ต๋๋ค.
import torch
import torch.nn as nn
from torchvision.models import resnet50
# simple Module to normalize an image
class Normalize(nn.Module):
def __init__(self, mean, std):
super(Normalize, self).__init__()
self.mean = torch.Tensor(mean)
self.std = torch.Tensor(std)
def forward(self, x):
return (x - self.mean.type_as(x)[None,:,None,None]) / self.std.type_as(x)[None,:,None,None]
# values are standard normalization for ImageNet images,
# from https://github.com/pytorch/examples/blob/master/imagenet/main.py
norm = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# load pre-trained ResNet50, and put into evaluation mode (necessary to e.g. turn off batchnorm)
model = resnet50(pretrained=True)
model.eval()
# interpret the prediction
pred = model(norm(pig_tensor))
import json
with open("imagenet_class_index.json") as f:
imagenet_classes = {int(i):x[1] for i,x in json.load(f).items()}
print(imagenet_classes[pred.max(dim=1)[1].item()])
hog
์ ๊ฒฐ๊ณผ๋ฅผ ํตํด, ๋ชจ๋ธ์ด ํด๋น ์ฌ์ง์ ๋ผ์ง(โhogโ)์์ ์ ํํ ๋ง์ถ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ๋ชจ๋ธ์ด ์ ๋ต์ ์ ์ถ๋ ฅํ ์ ์๋ ์ด์ ๋, ๋ชจ๋ธ์ ์๋์ ๊ฐ์ ํ์ต ๋ชฉํ๋ฅผ ์ ๋ฌ์ฑํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
\begin{equation} \label{eq:min} \min_\theta \ell(h_\theta(x), y) \end{equation}
์ด ๋, \(h\)๋ ๋ชจ๋ธ์ ์๋ฏธํ๋ฉฐ, \(\theta\)๋ ํ์ต ๋์์ด ๋๋ ๋ชจ๋ธ์ ๋งค๊ฐ๋ณ์(parameter) ์๋ฏธ ํฉ๋๋ค. \(h_\theta(x)\)์ \(y\) ์ฌ์ด์ ์ฐจ์ด๋ฅผ ์ ์ํ๋ ์์คํจ์(loss function) \(\ell\)๋ฅผ ์ต์ํํ์ฌ, ์ฐ๋ฆฌ๋ ๋ชจ๋ธ์ด ํน์ ์ด๋ฏธ์ง \(x\)์ ๋ํ ๊ฒฐ๊ณผ๊ฐ์ธ \(h_\theta(x)\)์ ์ ๋ต์ธ \(y\)๊ณผ ์ ์ฌํ ์์ธก์ ํ ์ ์๋๋ก ์ ๋ํฉ๋๋ค.
์ ๋์ ์์ ๋ โ๋ชจ๋ธ์ ์์ด๊ธฐโ ์ํด ๊ณ ์๋ ๊ฐ๋ ์ ๋๋ค. ๋ฐ๋ผ์, ์ ๋์ ์์ ๋ ์์ ํ์ต ๋ชฉํ๋ฅผ ์ ํดํ๊ธฐ ์ํด ์ต์ํํ๋ ์์คํจ์๋ฅผ ์ญ์ผ๋ก ์ต๋ํํ๋ ๋ฐ์ ์ค์ ์ ๋ก๋๋ค.
\begin{equation} \label{eq:max} \max_{\hat{x}} \ell(h_\theta(\hat{x}), y) \end{equation}
์ ์์ \(\ell(h_\theta(\hat{x}), y)\)์ ์ต๋ํํ๋ ์๋ก์ด ์ด๋ฏธ์ง์ธ \(\hat{x}\)๋ฅผ ์ฐพ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค. ๋ณธ ๊ณผ์ ์ ๊ฑฐ์ณ ์์ฑ๋ ์ด๋ฏธ์ง ํน์ ์์ ๋ฅผ ์ ๋์ ์์ (adversarial example)๋ผ๊ณ ๋ถ๋ฅด๊ฒ ๋ฉ๋๋ค.
๋์๊ฐ, ์ ์์ ์ธ ์ฌ์ฉ์๋ ์ฌ๋์ด ๋ณด๊ธฐ์๋ ๋ผ์ง์ด์ง๋ง, ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ๋ผ์ง๊ฐ ์๋๋ผ๊ณ ํ๋ ์์ ๋ฅผ ๋ง๋๋ ๊ฒ์ด ๋ชฉํ์ ๋๋ค. ๋ฐ๋ผ์, ์ ๋์ ์์ \(\hat{x}=x+\delta\)๋ฅผ ๋ง๋ค ๋ ๋ํด์ง๋ ๋ ธ์ด์ฆ \(\delta\)๋ ์ฌ๋์ด ๋์น์ฑ์ง ๋ชปํ๋ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋๋ก ์ ํ๋ฉ๋๋ค.
\begin{equation} \label{eq:max2} \max_{\delta\in\Delta} \ell(h_\theta(x+\delta), y) \end{equation}
๋ณธ ์กฐ๊ฑด ํ์ ๊ตฌํด์ง ๋ ธ์ด์ฆ \(\delta\)๋ฅผ ์ ๋์ ์ญ๋(adversarial perturbation) ํน์ ์ ๋์ ๋ ธ์ด์ฆ(adversarial noise)๋ผ๊ณ ๋ถ๋ฅด๊ฒ ๋ฉ๋๋ค.
์๋ฅผ Pytorch๋ก ๊ตฌํํ๋ค๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
import torch.optim as optim
epsilon = 2./255
delta = torch.zeros_like(pig_tensor, requires_grad=True)
opt = optim.SGD([delta], lr=1e-1)
for t in range(30):
pred = model(norm(pig_tensor + delta)) # ์ญ๋(๋
ธ์ด์ฆ) ์ถ๊ฐ ํ ์์ธก
loss = -nn.CrossEntropyLoss()(pred, torch.LongTensor([341])) # ์์ค๊ฐ ๊ณ์ฐ
if t % 5 == 0:
print(t, loss.item())
opt.zero_grad()
loss.backward() # ์์คํจ์ ์ต๋ํ (9๋ฒ์ ์์ค๊ฐ์ -๊ฐ ๊ณฑํด์ก์ผ๋ฏ๋ก)
opt.step()
delta.data.clamp_(-epsilon, epsilon) # ํฌ๊ธฐ ์ ํ
print("True class probability:", nn.Softmax(dim=1)(pred)[0,341].item())
0 -0.0038814544677734375
5 -0.00693511962890625
10 -0.015821456909179688
15 -0.08086681365966797
20 -12.229072570800781
25 -14.300384521484375
True class probability: 1.4027455108589493e-06
์ ๋ผ์ง ์ด๋ฏธ์ง๋ ์ฌ๋์ ๋์๋ ํ๋ฆผ์์ด ๋ผ์ง์ด์ง๋ง, ๋ชจ๋ธ์ ๋์๋ ์๋์ ๊ฐ์ด 99%์ ํ๋ฅ ๋ก ์๋ฑ(wombat)์ด๋ผ๋ ๋ค๋ฅธ ๋๋ฌผ๋ก ๋ถ๋ฅ๋ฉ๋๋ค.
Predicted class: wombat
Predicted probability: 0.9997960925102234
์ด๋ฅผ ์์ฉํ๋ฉด, ๋ชจ๋ธ์ด ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๋ต์ ๋ด๋๋๋กํ๋ ์ ๋์ ์์ ๋ฅผ ๊ตฌํ ์๋ ์์ต๋๋ค.
delta = torch.zeros_like(pig_tensor, requires_grad=True)
opt = optim.SGD([delta], lr=5e-3)
for t in range(100):
pred = model(norm(pig_tensor + delta))
loss = (-nn.CrossEntropyLoss()(pred, torch.LongTensor([341])) +
nn.CrossEntropyLoss()(pred, torch.LongTensor([404])))
if t % 10 == 0:
print(t, loss.item())
opt.zero_grad()
loss.backward()
opt.step()
delta.data.clamp_(-epsilon, epsilon)
0 24.00604820251465
10 -0.1628284454345703
20 -8.026773452758789
30 -15.677117347717285
40 -20.60370635986328
50 -24.99606704711914
60 -31.009849548339844
70 -34.80946350097656
80 -37.928680419921875
90 -40.32395553588867
max_class = pred.max(dim=1)[1].item()
print("Predicted class: ", imagenet_classes[max_class])
print("Predicted probability:", nn.Softmax(dim=1)(pred)[0,max_class].item())
Predicted class: airliner
Predicted probability: 0.9679961204528809
์ด ์ธ์๋ ๋ค์ํ ์ ๋์ ์์ ๋ฅผ ์์ฑํด๋ด๋ ๋ค์์ ์ ๋์ ๊ณต๊ฒฉ ๋ฐฉ๋ฒ์ด ์กด์ฌํฉ๋๋ค. ์์ธํ ์ฌํญ์ torchattacks๋ฅผ ์ฐธ๊ณ ๋ฐ๋๋๋ค.
์ ๋์ ๊ฐ๊ฑด์ฑ๊ณผ ์ ๋์ ๋ฐฉ์ด
2003๋ ์ ์ ๋์ ์์ ์ ์กด์ฌ๊ฐ ๋ฐ๊ฒฌ๋ ์ดํ, ์ ํ ๋ ผ๋ฌธ๋ค์ ๋ชจ๋ธ์ด ์ ๋์ ์์ ์ ๋ํด์๋ ์ ํํ ๊ฒฐ๊ณผ๋ฅผ ๋ผ ์ ์๋ ๋ฐฉ๋ฒ์ ๊ณ ์ํด์์ต๋๋ค. ์ ๋์ ๊ฐ๊ฑด์ฑ(Adversarial Robustness)์ โ๋ชจ๋ธ์ด ์ ๋์ ๊ณต๊ฒฉ์๋ ์ผ๋ง๋ ์ ๋ฒํธ ์ ์๋์งโ๋ฅผ ์์นํํ ์งํ๋ผ๊ณ ํ ์ ์์ต๋๋ค. ๋์๊ฐ, ์ ๋์ ๊ณต๊ฒฉ์ ๋ํ ๊ฐ๊ฑด์ฑ์ ๋์ด๊ธฐ ์ํ ๋ฐฉ๋ฒ์ ์ ๋์ ๋ฐฉ์ด(Adversarial Defense)๋ผ๊ณ ๋ถ๋ฅด๊ฒ ๋ฉ๋๋ค.
๋ค์ํ ์ ๋์ ๋ฐฉ์ด ๊ธฐ๋ฒ๋ค์ด ์ ์๋์์ง๋ง, ๊ทธ ์ค์์๋ ํ๋ฐํ๊ฒ ์ฐ๊ตฌ๋๊ณ ์๋ ๋ฐฉ์ด ๊ธฐ๋ฒ์ ์ ๋์ ํ์ต(Adversarial Training)์ ๋๋ค. ์ ๋์ ํ์ต์ด๋ ๋ชจ๋ธ ํ์ต ์ค์ ์ ๋์ ์์ ๋ฅผ ๋ง์ถ๋๋ก ํ์ตํ์ฌ ๊ฐ๊ฑด์ฑ์ ๋์ด๋ ๋ฐฉ๋ฒ์ ๋๋ค. ์ฆ, ๋ฐฑ์ ์ ๋ง๋ ๊ฒ๊ณผ ์ ์ฌํ ์๋ฆฌ๊ฐ ๋๊ฒ ์ต๋๋ค.
์ด๋ ์ํ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ min-max ๋ฌธ์ ๊ฐ ๋ฉ๋๋ค.
\begin{equation} \min_{\theta} \max_{\hat{x}} \ell(h_\theta(\hat{x}), y) \end{equation}
์์ min-max ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด, ๋ค์ํ ์ ๋์ ๋ฐฉ์ด ๊ธฐ๋ฒ(AT, TRADES, MART ๋ฑ)์ด ์ ์๋์์ผ๋ฉฐ, ๋น์ฝ์ ์ธ ๊ฐ๊ฑด์ฑ ํฅ์์ ์ด๋ฃจ์ด๋์ต๋๋ค. ๋ณด๋ค ์ต์ ์์น๋ https://robustbench.github.io/๋ฅผ ์ฐธ๊ณ ๋ฐ๋๋๋ค.
๋ณธ๋ก
ํ์ฌ๊น์ง์ ๋ค์ํ ์ ๋์ ๋ฐฉ์ด ๊ธฐ๋ฒ๋ค์ ๊ฐ์ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ๋์ ๊ฐ๊ฑด์ฑ์ ๋ฌ์ฑํด์์ต๋๋ค. ๊ทธ ๊ณผ์ ์์, ์ ํ ๋ ผ๋ฌธ๋ค์ โ๋ชจ๋ธ์ ํน์ ํน์ฑ(measure)์ด ์ข์ผ๋ฉด, ๊ฐ๊ฑด์ฑ๋ ์ข๋คโ๋ผ๋ ์ ๊ฐ ๋ฐฉ์์ ์ฑํํด์ค๊ธฐ๋ ํ์ต๋๋ค. ํน์ ํน์ฑ์ผ๋ก๋ ๋ง์ง(margin), ๊ฒฝ๊ณ๋ฉด ๋๊ป(boundary thickness), ๋ฆฝ์์ธ ๊ณ์(Lipschitz Value) ๋ฑ์ด ๊ฑฐ๋ก ๋์์ต๋๋ค.
๋ณธ ๋ ผ๋ฌธ์ โ๊ณผ์ฐ ๊ทธ๋ฌํ ์ฐ๊ตฌ ๊ฐ์ค๋ค์ด ์คํ์ ์ผ๋ก๋ ๊ฒ์ฆ๋ ์ ์๋๊ฐ?โ์ ๋ํ ๊ณ ์ฐฐ์ ๋ด๊ณ ์์ต๋๋ค. ์ ํ ๋ ผ๋ฌธ์์ ์์ฃผ ์ฌ์ฉ๋๋ 8๊ฐ์ ํ์ต ํ๊ฒฝ(๋ชจ๋ธ ๊ตฌ์กฐ, ์ ๋์ ๋ฐฉ์ด ๊ธฐ๋ฒ, ๋ฐฐ์น ์ฌ์ด์ฆ ๋ฑ)์ ๊ณ ๋ คํ์ฌ ์ด 1,300๊ฐ๊ฐ ๋๋ ๋ชจ๋ธ์ CIFAR-10 ์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ๋ํด ํ์ต์์ผฐ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ , ๊ฐ ๋ชจ๋ธ์ ํน์ฑ๋ค์ ์ธก์ ํ ๋ค, ํด๋น ํน์ฑ(measure)์ด ์ค์ ๋ก ๊ฐ๊ฑด์ฑ(robustness)์ ์ ์๋ฏธํ ๊ด๊ณ๋ฅผ ๊ฐ๋์ง ํ์ ํ์์ต๋๋ค.
๋ณธ ๋ ผ๋ฌธ์์๋ ๊ฐ๊ฑด์ฑ ๊ฐ ์์ฒด๋ณด๋ค๋ ํด๋น ๋ชจ๋ธ์ด ํ์ต ๋ฐ์ดํฐ(training set)์ ๋ํ ๊ฐ๊ฑด์ฑ๊ณผ ํ๊ฐ ๋ฐ์ดํฐ(test set)์ ๋ํ ๊ฐ๊ฑด์ฑ์ ์ฐจ์ด๊ฐ ์ผ๋ง๋ ์์์ง๋ฅผ ํ์ธํ๊ธฐ ์ํด โ๊ฐ๊ฑด์ฑ ์ผ๋ฐํ ์ฐจ์ด(Robust generalization gap)โ๋ฅผ ์ธก์ ํ์์ต๋๋ค. (โป ๋ถ๋ก์ ํตํด ๊ฐ๊ฑด์ฑ ๊ฐ ์์ฒด๋ฅผ ์ธก์ ํ๋ฉด ํฌ๊ฒ ์ ์๋ฏธํ ๊ฒฐ๊ณผ๊ฐ ์์์ ํ์ ํ ์ ์์ต๋๋ค)
๋ณธ ๋ ผ๋ฌธ์์ ์ ์๋ ํ๊ฐ ๋ฐฉ๋ฒ์ ์ํ ํ์ธ ๊ฒฐ๊ณผ, ์ ํ ์ฐ๊ตฌ์์ ์ ์๋ ํน์ฑ๋ค ์ค ์๋ฒฝํ ๊ฐ๊ฑด์ฑ๊ณผ ๋น๋กํ๋ ํน์ฑ์ ์กด์ฌํ์ง ์์์ต๋๋ค. ํนํ, ์ ๋์ ๋ฐฉ์ด ๋ฐฉ๋ฒ์ ๋ฐ๋ผ์๋ ํธ์ฐจ๊ฐ ํฐ ํน์ฑ๋ค์ด ๋ง์์ผ๋ฉฐ, ๋ํ์ ์ผ๋ก ๊ฒฝ๊ณ๋ฉด ๋๊ป(boundary thickness)๊ฐ ๊ทธ๋ฌํ์์ต๋๋ค.
์คํ๋ ค, ๊ธฐ์กด์ ๊ฐ๊ฑด์ฑ๊ณผ ๊ธด๋ฐํ ์๊ด ๊ด๊ณ๊ฐ ์๋ค๊ณ ์๋ ค์ง ๋ง์ง(margin)์ด๋ ์์คํจ์์ ํํํจ(Flatness)๋ ๊ธฐ์กด ํด์๋ค๊ณผ ์ ๋ฐ๋๋๋ ๋ชจ์ต์ ๋ณด์ด๊ธฐ๋ ํ์ต๋๋ค.
ํน์ ์กฐ๊ฑด ํ์์๋ ๊ธฐ์กด์ ์ฃผ๋ชฉ์ ์ ๋ฐ์ง ๋ชปํ๋ ์ ๋ ฅ ๊ธฐ์ธ๊ธฐ์ ํฌ๊ธฐ(Input gradient norm)์ด ๊ฐ๊ฑด์ฑ ์ผ๋ฐํ ์ฐจ์ด์ ๊ฐ์ฅ ๋์ ์๊ด๊ด๊ณ๊ฐ ์์์ ๋ณด์ด๊ธฐ๋ ํ์ต๋๋ค.
๋ณธ ๋ ผ๋ฌธ์ ์์ฒด์ ์ผ๋ก ํ์ตํ 1,300๊ฐ ๋ชจ๋ธ ์ด์ธ์๋, https://robustbench.github.io/์ ์ ๋ก๋๋ ๋ฒค์น๋งํฌ(Benchmark) ๋ชจ๋ธ์ ๋ํด์๋ ํ๊ฐ๋ฅผ ์งํํ์์ผ๋ฉฐ, ์ ์ฌํ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํด๋ด์์ต๋๋ค.
๊ฒฐ๋ก
๊ฐ๊ฑด์ฑ์ ์ธ๊ณต์ง๋ฅ์ ์ ๋ขฐ์ฑ ๋ถ๋ฌธ์์ ํต์ฌ ๊ฐ๋ ์ค ํ๋์ ๋๋ค. ๋ชจ๋ธ์ ๊ฐ๊ฑด์ฑ์ ๋์ด๋ ๊ฒ์ ๋ฏธ๋ ์์ ํ ์ธ๊ณต์ง๋ฅ ์ฌ์ฉ์ ์ํด ํ๋ฐํ ์ฐ๊ตฌ๋์ด์ผ ํ ๋ถ์ผ์ ๋๋ค. ๋ณธ ์ฐ๊ตฌ๋ โA ๋ชจ๋ธ์ด B ๋ชจ๋ธ๋ณด๋ค ์ด ํน์ฑ์ด ์ข์์ ๋ ์ฐ์ํ ๋ฏํ๋คโ๋ผ๋ ๋ช ์ ๋ ์ถฉ๋ถํ ํ ์คํธ ๋ฒ ๋๋ฅผ ํตํด ๊ฒ์ฆ๋์ด์ผ ํจ์ ์๊ธฐ์ํค๋ฉฐ, ๋ณด๋ค ์ํํ ๊ฒ์ฆ์ ์ํด PyTorch ๊ธฐ๋ฐ์ ์ ๋์ ๋ฐฉ์ด ํ๋ ์์ํฌ [MAIR]๋ฅผ ์ ์ํ์์ต๋๋ค. ๋ค์ํ ํน์ฑ์ ๋ํ ๋ณธ ๋ ผ๋ฌธ์ ๋ฐ๊ฒฌ์ด ์ ๋์ ๊ณต๊ฒฉ์ ๋ํ ๊ฐ๊ฑด์ฑ ๋ถ์ผ์ ๋ฐ์ ์ ๊ธฐ์ฌํ๊ธธ ๋ฐ๋๋๋ค.
๊ด๋ จ ์ฐ๊ตฌ์ค ๋ ผ๋ฌธ
- Understanding catastrophic overfitting in single-step adversarial training [AAAI 2021] | [Paper] | [Code]
- Graddiv: Adversarial robustness of randomized neural networks via gradient diversity regularization [IEEE Transactions on PAMI] | [Paper] | [Code]
- Generating transferable adversarial examples for speech classification [Pattern Recognition] | [Paper]