init

Author: wu-dx16

AT_AWP/awp.py

@@ -0,0 +1,55 @@
+# This is a simple implementation of AWP for Standard Adversarial Training (Madry)
+import copy
+import torch.nn as nn
+import torch.optim as optim
+import torch
+EPS = 1E-20
+
+
+def normalize(perturbations, weights):
+    perturbations.mul_(weights.norm()/(perturbations.norm() + EPS))
+
+
+def normalize_grad_by_weights(weights, ref_weights):
+    for w, ref_w in zip(weights, ref_weights):
+        if w.dim() <= 1:
+            w.grad.data.fill_(0)  # ignore perturbations with 1 dimension (e.g. BN, bias)
+        else:
+            normalize(w.grad.data, ref_w)
+
+
+class AdvWeightPerturb(object):
+    """
+    This is an implementation of AWP ONLY for Standard adversarial training
+    """
+    def __init__(self, model, eta, nb_iter=1):
+        super(AdvWeightPerturb, self).__init__()
+        self.eta = eta
+        self.nb_iter = nb_iter
+        self.model = model
+        self.optim = optim.SGD(model.parameters(), lr=eta/nb_iter)
+        self.criterion = nn.CrossEntropyLoss()
+        self.diff = None
+
+    def perturb(self, X_adv, y):
+        # store the original weight
+        old_w = copy.deepcopy([p.data for p in self.model.parameters()])
+
+        # perturb the model
+        for idx in range(self.nb_iter):
+            self.optim.zero_grad()
+            outputs = self.model(X_adv)
+            loss = - self.criterion(outputs, y)
+            loss.backward()
+
+            # normalize the gradient
+            normalize_grad_by_weights(self.model.parameters(), old_w)
+
+            self.optim.step()
+
+        # calculate the weight perturbation
+        self.diff = [w1 - w2 for w1, w2 in zip(self.model.parameters(), old_w)]
+
+    def restore(self):
+        for w, v in zip(self.model.parameters(), self.diff):
+            w.data.sub_(v.data)

AT_AWP/logs/cifar100_l2/preactresnet18_awp/output.log

@@ -0,0 +1,120 @@
+'''Pre-activation ResNet in PyTorch.
+
+Reference:
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Identity Mappings in Deep Residual Networks. arXiv:1603.05027
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class PreActBlock(nn.Module):
+    '''Pre-activation version of the BasicBlock.'''
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(PreActBlock, self).__init__()
+        self.bn1 = nn.BatchNorm2d(in_planes)
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+
+        if stride != 1 or in_planes != self.expansion*planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(x))
+        shortcut = self.shortcut(out) if hasattr(self, 'shortcut') else x
+        out = self.conv1(out)
+        out = self.conv2(F.relu(self.bn2(out)))
+        out += shortcut
+        return out
+
+
+class PreActBottleneck(nn.Module):
+    '''Pre-activation version of the original Bottleneck module.'''
+    expansion = 4
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(PreActBottleneck, self).__init__()
+        self.bn1 = nn.BatchNorm2d(in_planes)
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False)
+
+        if stride != 1 or in_planes != self.expansion*planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(x))
+        shortcut = self.shortcut(out) if hasattr(self, 'shortcut') else x
+        out = self.conv1(out)
+        out = self.conv2(F.relu(self.bn2(out)))
+        out = self.conv3(F.relu(self.bn3(out)))
+        out += shortcut
+        return out
+
+
+class PreActResNet(nn.Module):
+    def __init__(self, block, num_blocks, num_classes=10):
+        super(PreActResNet, self).__init__()
+        self.in_planes = 64
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
+        self.bn = nn.BatchNorm2d(512 * block.expansion)
+        self.linear = nn.Linear(512*block.expansion, num_classes)
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        strides = [stride] + [1]*(num_blocks-1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = self.conv1(x)
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.layer4(out)
+        out = F.relu(self.bn(out))
+        out = F.avg_pool2d(out, 4)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+
+def PreActResNet18(num_classes=10):
+    return PreActResNet(PreActBlock, [2,2,2,2], num_classes=num_classes)
+
+def PreActResNet34():
+    return PreActResNet(PreActBlock, [3,4,6,3])
+
+def PreActResNet50():
+    return PreActResNet(PreActBottleneck, [3,4,6,3])
+
+def PreActResNet101():
+    return PreActResNet(PreActBottleneck, [3,4,23,3])
+
+def PreActResNet152():
+    return PreActResNet(PreActBottleneck, [3,8,36,3])
+
+
+def test():
+    net = PreActResNet18()
+    y = net((torch.randn(1,3,32,32)))
+    print(y.size())
+
+# test()