update

examples/face_adversarial_attack/example/AFR.py

@@ -22,10 +22,10 @@ import face_recognition_models as frm
 from PIL import Image, ImageDraw
 import mindspore
 from mindspore.dataset.vision.py_transforms import ToPIL as ToPILImage
-from mindspore import Parameter,ops, nn,Tensor
+from mindspore import Parameter, ops, nn, Tensor
 from mindspore.dataset.vision.py_transforms import ToTensor
 import mindspore.dataset.vision.py_transforms as P
-from loss_design import TrainOneStepCell,MyWithLossCell,FaceLoss_no_target_attack,FaceLoss_target_attack
+from loss_design import TrainOneStepCell,MyWithLossCell, FaceLossTargeTattack,FaceLossNoTargetAttack
 from FaceRecognition.eval import get_net
 
 class Attack(object):
@@ -33,7 +33,7 @@ class Attack(object):
     Class used to create adversarial facial recognition attacks
     """
 
-    def __init__(self,input_img,target_img,seed=None):
+    def __init__(self, input_img, target_img, seed=None):
         """
         Initialization for Attack class.
 
@@ -44,7 +44,7 @@ class Attack(object):
 
         """
 
-        if (seed != None): np.random.seed(seed)
+        if (seed is not None): np.random.seed(seed)
         self.MEAN = Tensor([0.485, 0.456, 0.406])
         self.STD = Tensor([0.229, 0.224, 0.225])
         self.LOSS = Tensor(0)
@@ -56,11 +56,12 @@ class Attack(object):
         self.input_tensor = Tensor(self.normalize(self.tensorize(input_img)))
         self.target_tensor = Tensor(self.normalize(self.tensorize(target_img)))
         mp.imsave('./outputs/input图像.jpg', np.transpose(self._reverse_norm(self.input_tensor).asnumpy(), (1, 2, 0)))
-        mp.imsave('./outputs/target图像.jpg', np.transpose(self._reverse_norm(self.target_tensor).asnumpy(), (1, 2, 0)))
+        mp.imsave('./outputs/target图像.jpg',
+                  np.transpose(self._reverse_norm(self.target_tensor).asnumpy(), (1, 2, 0)))
 
 
-        self.input_emb = self.resnet(self.expand_dims(self.input_tensor,0))
-        self.target_emb = self.resnet(self.expand_dims(self.target_tensor,0))
+        self.input_emb = self.resnet(self.expand_dims(self.input_tensor, 0))
+        self.target_emb = self.resnet(self.expand_dims(self.target_tensor, 0))
         self.adversarial_emb = None
         self.mask_tensor = self._create_mask(input_img)
         self.ref = self.mask_tensor
@@ -69,28 +70,29 @@ class Attack(object):
 
 
 
-    def train(self,attack_method):
+    def train(self, attack_method):
         """
         Optimized adversarial image.
         """
 
         if attack_method == "non-target attack":
-            LOSS = FaceLoss_no_target_attack(self.target_emb)
+            LOSS = FaceLossNoTargetAttack(self.target_emb)
         if attack_method == "target_attack":
-            LOSS = FaceLoss_target_attack(self.target_emb)
+            LOSS = FaceLossTargeTattack(self.target_emb)
 
-        net_with_criterion = MyWithLossCell(self.resnet, LOSS,self.input_tensor)
+        net_with_criterion = MyWithLossCell(self.resnet, LOSS, self.input_tensor)
         train_net = TrainOneStepCell(net_with_criterion, self.opt)
 
         for i in range(2000):
 
             self.mask_tensor = Tensor(self.pm)
 
-            grads,loss = train_net(self.mask_tensor)
+            grads, loss = train_net(self.mask_tensor)
 
             print("epoch %d ,loss: %f \n " % (i, loss.asnumpy().item()))
 
-            self.mask_tensor = ops.clip_by_value(self.mask_tensor, Tensor(0, mindspore.float32), Tensor(1, mindspore.float32))
+            self.mask_tensor = ops.clip_by_value(
+                self.mask_tensor, Tensor(0, mindspore.float32), Tensor(1, mindspore.float32))
 
         adversarial_tensor = self._apply(
             self.input_tensor,
@@ -124,15 +126,16 @@ class Attack(object):
         print("================================")
         print("adversarial:", adversarial)
         print("adversarial_confidence:", self.adversarial_emb.asnumpy()[0][adversarial])
-        print("Confidence changes for target::", self.adversarial_emb.asnumpy()[0][target])
+        print("Confidence changes for target:", self.adversarial_emb.asnumpy()[0][target])
         print("Confidence changes for input:", self.adversarial_emb.asnumpy()[0][input])
         print("================================")
         print("target:", target)
         print("target_confidence:", self.target_emb.asnumpy()[0][target])
-        print("input:%d, target:%d, adversarial:%d" % (input,target, adversarial))
+        print("input: %d, target: %d, adversarial: %d" % (input, target, adversarial))
 
-    def test1(self,adversarial_tensor):
-        self.adversarial_emb = self.resnet(self.expand_dims((adversarial_tensor - self.MEAN[:, None, None]) / self.STD[:, None, None], 0))
+    def test1(self, adversarial_tensor):
+        self.adversarial_emb = self.resnet(
+            self.expand_dims((adversarial_tensor - self.MEAN[:, None, None]) / self.STD[:, None, None], 0))
         self.input_emb = self.resnet(self.expand_dims(self.input_tensor, 0))
         self.target_emb = self.resnet(self.expand_dims(self.target_tensor, 0))
 

examples/face_adversarial_attack/example/loss_design.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 import mindspore
-from mindspore import ops, nn,Tensor
+from mindspore import ops, nn, Tensor
 from mindspore.dataset.vision.py_transforms import ToTensor
 import mindspore.dataset.vision.py_transforms as P
 
@@ -41,17 +41,17 @@ class TrainOneStepCell(nn.Cell):
         self.weights = self.optimizer.parameters
         self.grad = ops.composite.GradOperation(get_all=True, sens_param=False)
 
-    def construct(self,*inputs):
+    def construct(self, *inputs):
         """Defines the computation performed."""
         loss = self.network(*inputs)
         grads = self.grad(self.network)(*inputs)
         self.optimizer(grads)
-        return grads,loss
+        return grads, loss
 
 
 
 class MyWithLossCell(nn.Cell):
-   def __init__(self,net,loss_fn,input_tensor):
+   def __init__(self, net, loss_fn, input_tensor):
        super(MyWithLossCell, self).__init__(auto_prefix=False)
        self.net = net
        self._loss_fn = loss_fn
@@ -63,11 +63,14 @@ class MyWithLossCell(nn.Cell):
        self.input_tensor = input_tensor
        self.input_emb = self.net(self.expand_dims(self.input_tensor, 0))
 
-   def construct(self,mask_tensor):
+   def construct(self, mask_tensor):
        ref = mask_tensor
-       adversarial_tensor = mindspore.numpy.where((ref == 0), self.input_tensor, (mask_tensor - self.MEAN[:, None, None] )/ self.STD[:, None, None])
+       adversarial_tensor = mindspore.numpy.where(
+           (ref == 0),
+           self.input_tensor,
+           (mask_tensor - self.MEAN[:, None, None] )/ self.STD[:, None, None])
        adversarial_emb =  self.net(self.expand_dims(adversarial_tensor, 0))
-       loss = self._loss_fn( adversarial_emb,self.input_emb,mask_tensor)
+       loss = self._loss_fn( adversarial_emb, self.input_emb, mask_tensor)
        return loss
 
    @property
@@ -75,11 +78,11 @@ class MyWithLossCell(nn.Cell):
        return self.net
 
 
-class FaceLoss_target_attack(nn.Cell):
+class FaceLossTargeTattack(nn.Cell):
     """The loss function of the target attack"""
 
-    def __init__(self,target_emb):
-        super(FaceLoss_target_attack, self).__init__()
+    def __init__(self, target_emb):
+        super(FaceLossTargeTattack, self).__init__()
         self.uniformreal = ops.UniformReal(seed=2)
         self.sum = ops.ReduceSum(keep_dims=False)
         self.norm = nn.Norm(keep_dims=True)
@@ -92,7 +95,7 @@ class FaceLoss_target_attack(nn.Cell):
         self.abs = ops.Abs()
         self.reduce_mean = ops.ReduceMean()
 
-    def construct(self, adversarial_emb,input_emb,mask_tensor):
+    def construct(self, adversarial_emb, input_emb, mask_tensor):
         #像素平滑
         # vert_diff = mask_tensor[:, 1:] - mask_tensor[:, :-1]
         # hor_diff = mask_tensor[:, :, 1:] - mask_tensor[:, :, :-1]
@@ -116,11 +119,11 @@ class FaceLoss_target_attack(nn.Cell):
         return loss
 
 
-class FaceLoss_no_target_attack(nn.Cell):
+class FaceLossNoTargetAttack(nn.Cell):
     """The loss function of the non-target attack"""
     def __init__(self, target_emb):
         """初始化"""
-        super(FaceLoss_no_target_attack, self).__init__()
+        super(FaceLossNoTargetAttack, self).__init__()
         self.uniformreal = ops.UniformReal(seed=2)
         self.sum = ops.ReduceSum(keep_dims=False)
         self.norm = nn.Norm(keep_dims=True)

examples/face_adversarial_attack/example/test.py

@@ -15,7 +15,7 @@
 
 import numpy as np
 import matplotlib.image as mp
-from mindspore import context,Tensor
+from mindspore import context, Tensor
 import mindspore
 from mindspore.dataset.vision.py_transforms import ToTensor
 import mindspore.dataset.vision.py_transforms as P