def perturb_blur_eot(self, X_nat, y, c_trg):
"""
EoT adaptation to the blur transformation.
"""
if self.rand:
X = X_nat.clone().detach_() + torch.tensor(np.random.uniform(-self.epsilon, self.epsilon, X_nat.shape).astype('float32')).to(self.device)
else:
X = X_nat.clone().detach_()
# use the following if FGSM or I-FGSM and random seeds are fixed
# X = X_nat.clone().detach_() + torch.tensor(np.random.uniform(-0.001, 0.001, X_nat.shape).astype('float32')).cuda()
# Gaussian blur kernel size
ks_gauss = 11
# Average smoothing kernel size
ks_avg = 3
# Sigma for Gaussian blur
sig = 1
# Type of blur
blur_type = 1
for i in range(self.k):
full_loss = 0.0
X.requires_grad = True
self.model.zero_grad()
for j in range(9): # 9 types of blur
# Declare smoothing layer
if blur_type == 1:
preproc = smoothing.GaussianSmoothing2D(sigma=sig, channels=3, kernel_size=ks_gauss).to(self.device)
elif blur_type == 2:
preproc = smoothing.AverageSmoothing2D(channels=3, kernel_size=ks_avg).to(self.device)
output, feats = self.model.forward_blur(X, c_trg, preproc)
loss = self.loss_fn(output, y)
full_loss += loss
if blur_type == 1:
sig += 0.5
if sig >= 3.2:
blur_type = 2
sig = 1
if blur_type == 2:
ks_avg += 2
if ks_avg >= 11:
blur_type = 1
ks_avg = 3
full_loss.backward()
grad = X.grad
X_adv = X + self.a * grad.sign()
eta = torch.clamp(X_adv - X_nat, min=-self.epsilon, max=self.epsilon)
X = torch.clamp(X_nat + eta, min=-1, max=1).detach_()
self.model.zero_grad()
return X, X - X_nat
def perturb_blur_iter_full(self, X_nat, y, c_trg):
"""
Spread-spectrum attack against blur defenses (gray-box scenario).
"""
if self.rand:
X = X_nat.clone().detach_() + torch.tensor(np.random.uniform(-self.epsilon, self.epsilon, X_nat.shape).astype('float32')).to(self.device)
else:
X = X_nat.clone().detach_()
# use the following if FGSM or I-FGSM and random seeds are fixed
# X = X_nat.clone().detach_() + torch.tensor(np.random.uniform(-0.001, 0.001, X_nat.shape).astype('float32')).cuda()
# Gaussian blur kernel size
ks_gauss = 11
# Average smoothing kernel size
ks_avg = 3
# Sigma for Gaussian blur
sig = 1
# Type of blur
blur_type = 1
for i in range(self.k):
# Declare smoothing layer
if blur_type == 1:
preproc = smoothing.GaussianSmoothing2D(sigma=sig, channels=3, kernel_size=ks_gauss).to(self.device)
elif blur_type == 2:
preproc = smoothing.AverageSmoothing2D(channels=3, kernel_size=ks_avg).to(self.device)
X.requires_grad = True
output, feats = self.model.forward_blur(X, c_trg, preproc)
if self.feat:
output = feats[self.feat]
self.model.zero_grad()
loss = self.loss_fn(output, y)
loss.backward()
grad = X.grad
X_adv = X + self.a * grad.sign()
eta = torch.clamp(X_adv - X_nat, min=-self.epsilon, max=self.epsilon)
X = torch.clamp(X_nat + eta, min=-1, max=1).detach_()
# Iterate through blur types
if blur_type == 1:
sig += 0.5
if sig >= 3.2:
blur_type = 2
sig = 1
if blur_type == 2:
ks_avg += 2
if ks_avg >= 11:
blur_type = 1
ks_avg = 3
self.model.zero_grad()
return X, X - X_nat
def __init__(self, conv_dim=64, c_dim=5, repeat_num=6):
super(AvgBlurGenerator, self).__init__()
layers = []
layers.append(
nn.Conv2d(3 + c_dim,
conv_dim,
kernel_size=7,
stride=1,
padding=3,
bias=False))
layers.append(
nn.InstanceNorm2d(conv_dim, affine=True, track_running_stats=True))
layers.append(nn.ReLU(inplace=True))
# Down-sampling layers.
curr_dim = conv_dim
for i in range(2):
layers.append(
nn.Conv2d(curr_dim,
curr_dim * 2,
kernel_size=4,
stride=2,
padding=1,
bias=False))
layers.append(
nn.InstanceNorm2d(curr_dim * 2,
affine=True,
track_running_stats=True))
layers.append(nn.ReLU(inplace=True))
curr_dim = curr_dim * 2
# Bottleneck layers.
for i in range(repeat_num):
layers.append(ResidualBlock(dim_in=curr_dim, dim_out=curr_dim))
# Up-sampling layers.
for i in range(2):
layers.append(
nn.ConvTranspose2d(curr_dim,
curr_dim // 2,
kernel_size=4,
stride=2,
padding=1,
bias=False))
layers.append(
nn.InstanceNorm2d(curr_dim // 2,
affine=True,
track_running_stats=True))
layers.append(nn.ReLU(inplace=True))
curr_dim = curr_dim // 2
layers.append(
nn.Conv2d(curr_dim,
3,
kernel_size=7,
stride=1,
padding=3,
bias=False))
layers.append(nn.Tanh())
self.main = nn.Sequential(*layers)
layers_preproc = []
# layers_preproc.append(nn.ReflectionPad2d(2))
layers_preproc.append(
smoothing.AverageSmoothing2D(channels=3 + c_dim, kernel_size=21))
self.preprocessing = nn.Sequential(*layers_preproc)
