君君臣臣君
Gitee
3 years ago
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
9 changed files with 0 additions and 726 deletions
Unified View
Diff Options
-
+0 -292examples/face_adversarial_attack/example/AFR.py
-
+0 -86examples/face_adversarial_attack/example/README.md
-
+0 -34examples/face_adversarial_attack/example/camera.py
-
+0 -40examples/face_adversarial_attack/example/example_non-target_attack.py
-
+0 -41examples/face_adversarial_attack/example/example_target_attack.py
-
+0 -163examples/face_adversarial_attack/example/loss_design.py
-
BINexamples/face_adversarial_attack/example/opencv_photo/input/input1.jpg
-
BINexamples/face_adversarial_attack/example/opencv_photo/target/target1.jpg
-
+0 -70examples/face_adversarial_attack/example/test.py
+ 0
- 292
examples/face_adversarial_attack/example/AFR.py
View File
| @@ -1,292 +0,0 @@ | |||||
| # Copyright 2022 Huawei Technologies Co., Ltd | |||||
| # | |||||
| # Licensed under the Apache License, Version 2.0 (the "License"); | |||||
| # you may not use this file except in compliance with the License. | |||||
| # You may obtain a copy of the License at | |||||
| # | |||||
| # http://www.apache.org/licenses/LICENSE-2.0 | |||||
| # | |||||
| # Unless required by applicable law or agreed to in writing, software | |||||
| # distributed under the License is distributed on an "AS IS" BASIS, | |||||
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
| # See the License for the specific language governing permissions and | |||||
| # limitations under the License. | |||||
| # ============================================================================ | |||||
| import os | |||||
| import re | |||||
| import numpy as np | |||||
| import matplotlib.image as mp | |||||
| import dlib | |||||
| import face_recognition as fr | |||||
| 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.dataset.vision.py_transforms import ToTensor | |||||
| import mindspore.dataset.vision.py_transforms as P | |||||
| from loss_design import TrainOneStepCell,MyWithLossCell, FaceLossTargeTattack,FaceLossNoTargetAttack | |||||
| from FaceRecognition.eval import get_net | |||||
| class Attack(object): | |||||
| """ | |||||
| Class used to create adversarial facial recognition attacks | |||||
| """ | |||||
| def __init__(self, input_img, target_img, seed=None): | |||||
| """ | |||||
| Initialization for Attack class. | |||||
| Args: | |||||
| input_img : Image to train on. | |||||
| target_img : Image to target the adversarial attack against. | |||||
| seed : optional Sets custom seed for reproducability. Default is generated randomly. | |||||
| """ | |||||
| 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) | |||||
| self.expand_dims = mindspore.ops.ExpandDims() | |||||
| self.imageize = ToPILImage() | |||||
| self.tensorize = ToTensor() | |||||
| self.normalize = P.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) | |||||
| self.resnet = get_net() | |||||
| 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))) | |||||
| 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 | |||||
| self.pm = Parameter(self.mask_tensor) | |||||
| self.opt = nn.Adam([self.pm], learning_rate=0.01, weight_decay=0.0001) | |||||
| def train(self, attack_method): | |||||
| """ | |||||
| Optimized adversarial image. | |||||
| """ | |||||
| if attack_method == "non-target attack": | |||||
| LOSS = FaceLossNoTargetAttack(self.target_emb) | |||||
| if attack_method == "target_attack": | |||||
| LOSS = FaceLossTargeTattack(self.target_emb) | |||||
| 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) | |||||
| 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)) | |||||
| adversarial_tensor = self._apply( | |||||
| self.input_tensor, | |||||
| (self.mask_tensor - self.MEAN[:, None, None]) / self.STD[:, None, None], | |||||
| self.ref) | |||||
| adversarial_tensor = self._reverse_norm(adversarial_tensor) | |||||
| return adversarial_tensor, self.mask_tensor | |||||
| def test(self): | |||||
| """ | |||||
| Test the recognition of adversarial images by the model. | |||||
| """ | |||||
| adversarial_tensor = self._apply( | |||||
| self.input_tensor, | |||||
| (self.mask_tensor - self.MEAN[:, None, None] )/ self.STD[:, None, None], | |||||
| self.ref) | |||||
| self.adversarial_emb = self.resnet(self.expand_dims(adversarial_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)) | |||||
| adversarial = np.argmax(self.adversarial_emb.asnumpy()) | |||||
| target = np.argmax(self.target_emb.asnumpy()) | |||||
| input = np.argmax(self.input_emb.asnumpy()) | |||||
| print("input:", input) | |||||
| print("input_confidence:", self.input_emb.asnumpy()[0][input]) | |||||
| 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 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)) | |||||
| 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)) | |||||
| adversarial = np.argmax(self.adversarial_emb.asnumpy()) | |||||
| target = np.argmax(self.target_emb.asnumpy()) | |||||
| input = np.argmax(self.input_emb.asnumpy()) | |||||
| print("input:", input) | |||||
| print("input_confidence:", self.input_emb.asnumpy()[0][input]) | |||||
| print("================================") | |||||
| print("adversarial:", adversarial) | |||||
| print("adversarial_confidence:", self.adversarial_emb.asnumpy()[0][adversarial]) | |||||
| 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)) | |||||
| def _reverse_norm(self, image_tensor): | |||||
| """ | |||||
| Reverses normalization for a given image_tensor | |||||
| Args: | |||||
| image_tensor : Tensor | |||||
| Returns: | |||||
| Tensor | |||||
| """ | |||||
| tensor = image_tensor * self.STD[:, None, None] + self.MEAN[:, None, None] | |||||
| return tensor | |||||
| def _apply(self, | |||||
| image_tensor, | |||||
| mask_tensor, | |||||
| reference_tensor | |||||
| ): | |||||
| """ | |||||
| Apply a mask over an image. | |||||
| Args: | |||||
| image_tensor : Canvas to be used to apply mask on. | |||||
| mask_tensor : Mask to apply over the image. | |||||
| reference_tensor : Used to reference mask boundaries | |||||
| Returns: | |||||
| Tensor | |||||
| """ | |||||
| tensor = mindspore.numpy.where((reference_tensor == 0), image_tensor, mask_tensor) | |||||
| return tensor | |||||
| def _create_mask(self, face_image): | |||||
| """ | |||||
| Create mask image. | |||||
| Args: | |||||
| face_image : image of a detected face. | |||||
| Returns: | |||||
| mask_tensor : A mask image. | |||||
| """ | |||||
| mask = Image.new('RGB', face_image.size, color=(0, 0, 0)) | |||||
| d = ImageDraw.Draw(mask) | |||||
| landmarks = fr.face_landmarks(np.array(face_image)) | |||||
| area = [landmark | |||||
| for landmark in landmarks[0]['chin'] | |||||
| if landmark[1] > max(landmarks[0]['nose_tip'])[1]] | |||||
| area.append(landmarks[0]['nose_bridge'][1]) | |||||
| d.polygon(area, fill=(255, 255, 255)) | |||||
| mask_array = np.array(mask) | |||||
| mask_array = mask_array.astype(np.float32) | |||||
| for i in range(mask_array.shape[0]): | |||||
| for j in range(mask_array.shape[1]): | |||||
| for k in range(mask_array.shape[2]): | |||||
| if mask_array[i][j][k] == 255.: | |||||
| mask_array[i][j][k] = 0.5 | |||||
| else: | |||||
| mask_array[i][j][k] = 0 | |||||
| mask_tensor = Tensor(mask_array) | |||||
| mask_tensor = mask_tensor.swapaxes(0, 2).swapaxes(1, 2) | |||||
| mask_tensor.requires_grad = True | |||||
| return mask_tensor | |||||
| def _reverse_norm(self, image_tensor): | |||||
| """ | |||||
| Reverses normalization for a given image_tensor. | |||||
| Args: | |||||
| image_tensor : Tensor. | |||||
| Returns: | |||||
| Tensor. | |||||
| """ | |||||
| tensor = image_tensor * self.STD[:, None, None] + self.MEAN[:, None, None] | |||||
| return tensor | |||||
| def detect_face(image_loc): | |||||
| """ | |||||
| Helper function to run the facial detection and alignment process using | |||||
| dlib. Detects a given face and aligns it using dlib's 5 point landmark | |||||
| detector. | |||||
| Args: | |||||
| image_loc : image file location. | |||||
| Returns: | |||||
| face_image : Resized face image. | |||||
| """ | |||||
| detector = dlib.get_frontal_face_detector() | |||||
| shape_predictor = dlib.shape_predictor(frm.pose_predictor_model_location()) | |||||
| image = dlib.load_rgb_image(image_loc) | |||||
| dets = detector(image, 1) | |||||
| faces = dlib.full_object_detections() | |||||
| for detection in dets: | |||||
| faces.append(shape_predictor(image, detection)) | |||||
| face_image = Image.fromarray(dlib.get_face_chip(image, faces[0], size=112)) | |||||
| return face_image | |||||
| def load_data(path_to_data): | |||||
| """ | |||||
| Helper function for loading image data. Allows user to load the input, target, | |||||
| and test images. | |||||
| Args: | |||||
| path_to_data : Path to the given data. | |||||
| Returns: | |||||
| list : List of resized face images. | |||||
| """ | |||||
| img_files = [f for f in os.listdir(path_to_data) if re.search(r'.*\.(jpe?g|png)', f)] | |||||
| img_files_locs = [os.path.join(path_to_data, f) for f in img_files] | |||||
| image_list = [] | |||||
| for loc in img_files_locs: | |||||
| image_list.append(detect_face(loc)) | |||||
| return image_list | |||||
+ 0
- 86
examples/face_adversarial_attack/example/README.md
View File
| @@ -1,86 +0,0 @@ | |||||
| # 人脸识别物理对抗攻击 | |||||
| ##描述 | |||||
| 本项目是对人脸识别模型的物理对抗攻击，通过生成对抗口罩，使人脸佩戴后实现目标攻击和非目标攻击，并应用于mindspore平台。 | |||||
| ##模型结构 | |||||
| 采用华为mindspore官方训练的FaceRecognition模型 | |||||
| https://www.mindspore.cn/resources/hub/details?MindSpore/1.7/facerecognition_ms1mv2 | |||||
| ##环境要求 | |||||
| mindspore=1.7，硬件平台为GPU。 | |||||
| ##脚本说明 | |||||
| ├── readme.md | |||||
| ├── opencv_photo | |||||
| │ ├── adv_input //对抗图像 | |||||
| │ ├── input //输入图像 | |||||
| │ └── target //目标图像 | |||||
| ├── outputs //训练后的图像 | |||||
| ├── FaceRecognition //模型设置 | |||||
| ├── AFR.py //训练脚本 | |||||
| ├── camera.py //opencv图像采集 | |||||
| │── example_non-target_attack.py //无目标攻击训练 | |||||
| │── example_target_attack.py //目标攻击训练 | |||||
| │── loss_design.py //训练优化设置 | |||||
| └── test.py //评估攻击效果 | |||||
| ##模型调用 | |||||
| 方法一: | |||||
| #基于mindspore_hub库调用FaceRecognition模型 | |||||
| import mindspore_hub as mshub | |||||
| from mindspore import context | |||||
| def get_net(): | |||||
| context.set_context(mode=context.GRAPH_MODE, | |||||
| device_target="GPU", | |||||
| device_id=0) | |||||
| model = "mindspore/1.7/facerecognition_ms1mv2" | |||||
| network = mshub.load(model) | |||||
| network.set_train(False) | |||||
| return network | |||||
| 方法二: | |||||
| 利用 MindSpore代码仓中的https://gitee.com/mindspore/models/blob/master/research/cv/FaceRecognition/eval.py的get_model函数加载模型 | |||||
| ##训练过程 | |||||
| 目标攻击: | |||||
| $ cd face_adversarial_attack/example/ | |||||
| $ python example_target_attack.py | |||||
| 非目标攻击: | |||||
| $ cd face_adversarial_attack/example/ | |||||
| $ python example_non-target_attack.py | |||||
| ##默认训练参数 | |||||
| optimizer=adam, learning rate=0.01, weight_decay=0.0001, epoch=2000 | |||||
| ##评估过程 | |||||
| 评估方法一: | |||||
| AFR.Attack.test() | |||||
| 评估方法二: | |||||
| $ cd face_adversarial_attack/example/ | |||||
| $ python test.py | |||||
+ 0
- 34
examples/face_adversarial_attack/example/camera.py
View File
| @@ -1,34 +0,0 @@ | |||||
| # Copyright 2022 Huawei Technologies Co., Ltd | |||||
| # | |||||
| # Licensed under the Apache License, Version 2.0 (the "License"); | |||||
| # you may not use this file except in compliance with the License. | |||||
| # You may obtain a copy of the License at | |||||
| # | |||||
| # http://www.apache.org/licenses/LICENSE-2.0 | |||||
| # | |||||
| # Unless required by applicable law or agreed to in writing, software | |||||
| # distributed under the License is distributed on an "AS IS" BASIS, | |||||
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
| # See the License for the specific language governing permissions and | |||||
| # limitations under the License. | |||||
| # ============================================================================ | |||||
| import cv2 | |||||
| capture = cv2.VideoCapture(0) | |||||
| for i in range(2): | |||||
| while(True): | |||||
| ret, frame = capture.read() | |||||
| width, height = capture.get(3), capture.get(4) | |||||
| cv2.imwrite('./opencv_photo/input/input'+str(i)+'.png', frame) | |||||
| cv2.imshow('frame', frame) | |||||
| if cv2.waitKey(1) == ord('q'): | |||||
| break | |||||
| print(width, height) | |||||
| capture.release() | |||||
| cv2.destroyAllWindows() | |||||
+ 0
- 40
examples/face_adversarial_attack/example/example_non-target_attack.py
View File
| @@ -1,40 +0,0 @@ | |||||
| # Copyright 2022 Huawei Technologies Co., Ltd | |||||
| # | |||||
| # Licensed under the Apache License, Version 2.0 (the "License"); | |||||
| # you may not use this file except in compliance with the License. | |||||
| # You may obtain a copy of the License at | |||||
| # | |||||
| # http://www.apache.org/licenses/LICENSE-2.0 | |||||
| # | |||||
| # Unless required by applicable law or agreed to in writing, software | |||||
| # distributed under the License is distributed on an "AS IS" BASIS, | |||||
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
| # See the License for the specific language governing permissions and | |||||
| # limitations under the License. | |||||
| # ============================================================================ | |||||
| import numpy as np | |||||
| import matplotlib.image as mp | |||||
| from mindspore import context | |||||
| import AFR | |||||
| context.set_context(mode=context.GRAPH_MODE, device_target="GPU") | |||||
| if __name__ == '__main__': | |||||
| inputs = AFR.load_data('opencv_photo/input/') | |||||
| targets = AFR.load_data('opencv_photo/target/') | |||||
| adversarial = AFR.Attack(inputs[0], targets[0]) | |||||
| attack_method = "non-target attack" | |||||
| adversarial_tensor, mask_tensor = adversarial.train(attack_method) | |||||
| mp.imsave('./outputs/对抗图像.jpg', np.transpose(adversarial_tensor.asnumpy(), (1, 2, 0))) | |||||
| mp.imsave('./outputs/口罩.jpg', np.transpose(mask_tensor.asnumpy(), (1, 2, 0))) | |||||
| adversarial.test() | |||||
+ 0
- 41
examples/face_adversarial_attack/example/example_target_attack.py
View File
| @@ -1,41 +0,0 @@ | |||||
| # Copyright 2022 Huawei Technologies Co., Ltd | |||||
| # | |||||
| # Licensed under the Apache License, Version 2.0 (the "License"); | |||||
| # you may not use this file except in compliance with the License. | |||||
| # You may obtain a copy of the License at | |||||
| # | |||||
| # http://www.apache.org/licenses/LICENSE-2.0 | |||||
| # | |||||
| # Unless required by applicable law or agreed to in writing, software | |||||
| # distributed under the License is distributed on an "AS IS" BASIS, | |||||
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
| # See the License for the specific language governing permissions and | |||||
| # limitations under the License. | |||||
| # ============================================================================ | |||||
| import numpy as np | |||||
| import matplotlib.image as mp | |||||
| from mindspore import context | |||||
| import AFR | |||||
| context.set_context(mode=context.GRAPH_MODE, device_target="GPU") | |||||
| if __name__ == '__main__': | |||||
| inputs = AFR.load_data('opencv_photo/input/') | |||||
| targets = AFR.load_data('opencv_photo/target/') | |||||
| adversarial = AFR.Attack(inputs[0], targets[0]) | |||||
| attack_method = "target_attack" | |||||
| adversarial_tensor, mask_tensor = adversarial.train(attack_method) | |||||
| mp.imsave('./outputs/对抗图像.jpg', np.transpose(adversarial_tensor.asnumpy(), (1, 2, 0))) | |||||
| mp.imsave('./outputs/口罩.jpg', np.transpose(mask_tensor.asnumpy(), (1, 2, 0))) | |||||
| adversarial.test() | |||||
+ 0
- 163
examples/face_adversarial_attack/example/loss_design.py
View File
| @@ -1,163 +0,0 @@ | |||||
| # Copyright 2022 Huawei Technologies Co., Ltd | |||||
| # | |||||
| # Licensed under the Apache License, Version 2.0 (the "License"); | |||||
| # you may not use this file except in compliance with the License. | |||||
| # You may obtain a copy of the License at | |||||
| # | |||||
| # http://www.apache.org/licenses/LICENSE-2.0 | |||||
| # | |||||
| # Unless required by applicable law or agreed to in writing, software | |||||
| # distributed under the License is distributed on an "AS IS" BASIS, | |||||
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
| # See the License for the specific language governing permissions and | |||||
| # limitations under the License. | |||||
| # ============================================================================ | |||||
| import mindspore | |||||
| from mindspore import ops, nn, Tensor | |||||
| from mindspore.dataset.vision.py_transforms import ToTensor | |||||
| import mindspore.dataset.vision.py_transforms as P | |||||
| class TrainOneStepCell(nn.Cell): | |||||
| """ | |||||
| Encapsulation class of network training. | |||||
| Append an optimizer to the training network after that the construct | |||||
| function can be called to create the backward graph. | |||||
| Args: | |||||
| network (Cell): The training network. Note that loss function should have been added. | |||||
| optimizer (Optimizer): Optimizer for updating the weights. | |||||
| sens (Number): The adjust parameter. Default: 1.0. | |||||
| """ | |||||
| def __init__(self, network, optimizer, sens=1.0): | |||||
| super(TrainOneStepCell, self).__init__(auto_prefix=False) | |||||
| self.network = network | |||||
| self.network.set_grad() | |||||
| self.optimizer = optimizer | |||||
| self.weights = self.optimizer.parameters | |||||
| self.grad = ops.composite.GradOperation(get_all=True, sens_param=False) | |||||
| def construct(self, *inputs): | |||||
| """Defines the computation performed.""" | |||||
| loss = self.network(*inputs) | |||||
| grads = self.grad(self.network)(*inputs) | |||||
| self.optimizer(grads) | |||||
| return grads, loss | |||||
| class MyWithLossCell(nn.Cell): | |||||
| def __init__(self, net, loss_fn, input_tensor): | |||||
| super(MyWithLossCell, self).__init__(auto_prefix=False) | |||||
| self.net = net | |||||
| self._loss_fn = loss_fn | |||||
| self.STD = Tensor([0.229, 0.224, 0.225]) | |||||
| self.MEAN = Tensor([0.485, 0.456, 0.406]) | |||||
| self.expand_dims = mindspore.ops.ExpandDims() | |||||
| self.normalize = P.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) | |||||
| self.tensorize = ToTensor() | |||||
| self.input_tensor = input_tensor | |||||
| self.input_emb = self.net(self.expand_dims(self.input_tensor, 0)) | |||||
| 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_emb = self.net(self.expand_dims(adversarial_tensor, 0)) | |||||
| loss = self._loss_fn( adversarial_emb, self.input_emb, mask_tensor) | |||||
| return loss | |||||
| @property | |||||
| def backbone_network(self): | |||||
| return self.net | |||||
| class FaceLossTargeTattack(nn.Cell): | |||||
| """The loss function of the target attack""" | |||||
| 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) | |||||
| self.zeroslike = ops.ZerosLike() | |||||
| self.concat_op1 = ops.Concat(1) | |||||
| self.concat_op2 = ops.Concat(2) | |||||
| self.pow = ops.Pow() | |||||
| self.reduce_sum = ops.operations.ReduceSum() | |||||
| self.target_emb = target_emb | |||||
| self.abs = ops.Abs() | |||||
| self.reduce_mean = ops.ReduceMean() | |||||
| 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] | |||||
| # vert_diff_sq = self.pow(vert_diff, 2) | |||||
| # hor_diff_sq = self.pow(hor_diff, 2) | |||||
| # A = self.zeroslike(Tensor(self.uniformreal((3, 1, 112)))) | |||||
| # B = self.zeroslike(Tensor(self.uniformreal((3, 112, 1)))) | |||||
| # vert_pad = self.concat_op1((vert_diff_sq, A)) | |||||
| # hor_pad = self.concat_op2((hor_diff_sq, B)) | |||||
| # tv_sum = vert_pad + hor_pad | |||||
| # tv = ops.functional.sqrt(tv_sum + 1e-5) | |||||
| # tv_final_sum = self.sum(tv) | |||||
| # tv_loss = (1e-4) * tv_final_sum | |||||
| # print("tv_loss:",tv_loss) | |||||
| prod_sum = self.reduce_sum(adversarial_emb * self.target_emb, (1,)) | |||||
| square1 = self.reduce_sum(ops.functional.square(adversarial_emb), (1,)) | |||||
| square2 = self.reduce_sum(ops.functional.square(self.target_emb), (1,)) | |||||
| denom = ops.functional.sqrt(square1) * ops.functional.sqrt(square2) | |||||
| loss = -(prod_sum / denom) | |||||
| print("dis_loss:", loss) | |||||
| return loss | |||||
| class FaceLossNoTargetAttack(nn.Cell): | |||||
| """The loss function of the non-target attack""" | |||||
| def __init__(self, target_emb): | |||||
| """初始化""" | |||||
| super(FaceLossNoTargetAttack, self).__init__() | |||||
| self.uniformreal = ops.UniformReal(seed=2) | |||||
| self.sum = ops.ReduceSum(keep_dims=False) | |||||
| self.norm = nn.Norm(keep_dims=True) | |||||
| self.zeroslike = ops.ZerosLike() | |||||
| self.concat_op1 = ops.Concat(1) | |||||
| self.concat_op2 = ops.Concat(2) | |||||
| self.pow = ops.Pow() | |||||
| self.reduce_sum = ops.operations.ReduceSum() | |||||
| self.target_emb = target_emb | |||||
| self.abs = ops.Abs() | |||||
| self.reduce_mean = ops.ReduceMean() | |||||
| 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] | |||||
| # vert_diff_sq = self.pow(vert_diff, 2) | |||||
| # hor_diff_sq = self.pow(hor_diff, 2) | |||||
| # A = self.zeroslike(Tensor(self.uniformreal((3, 1, 112)))) # | |||||
| # B = self.zeroslike(Tensor(self.uniformreal((3, 112, 1)))) | |||||
| # vert_pad = self.concat_op1((vert_diff_sq, A)) | |||||
| # hor_pad = self.concat_op2((hor_diff_sq, B)) | |||||
| # tv_sum = vert_pad + hor_pad | |||||
| # tv = ops.functional.sqrt(tv_sum + 1e-5) | |||||
| # tv_final_sum = self.sum(tv) | |||||
| # tv_loss = (1e-4) * tv_final_sum | |||||
| # print("tv_loss:",tv_loss) | |||||
| prod_sum = self.reduce_sum(adversarial_emb * input_emb, (1,)) | |||||
| square1 = self.reduce_sum(ops.functional.square(adversarial_emb), (1,)) | |||||
| square2 = self.reduce_sum(ops.functional.square(input_emb), (1,)) | |||||
| denom = ops.functional.sqrt(square1) * ops.functional.sqrt(square2) | |||||
| loss = prod_sum / denom | |||||
| print("cosine_loss:", loss) | |||||
| return loss | |||||
BIN
examples/face_adversarial_attack/example/opencv_photo/input/input1.jpg
View File
| Before | After |
|---|---|
|
|
| Width: 1024 | Height: 774 | Size: 88 kB |
BIN
examples/face_adversarial_attack/example/opencv_photo/target/target1.jpg
View File
| Before | After |
|---|---|
|
|
| Width: 1523 | Height: 2048 | Size: 653 kB |
+ 0
- 70
examples/face_adversarial_attack/example/test.py
View File
| @@ -1,70 +0,0 @@ | |||||
| # Copyright 2022 Huawei Technologies Co., Ltd | |||||
| # | |||||
| # Licensed under the Apache License, Version 2.0 (the "License"); | |||||
| # you may not use this file except in compliance with the License. | |||||
| # You may obtain a copy of the License at | |||||
| # | |||||
| # http://www.apache.org/licenses/LICENSE-2.0 | |||||
| # | |||||
| # Unless required by applicable law or agreed to in writing, software | |||||
| # distributed under the License is distributed on an "AS IS" BASIS, | |||||
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
| # See the License for the specific language governing permissions and | |||||
| # limitations under the License. | |||||
| # ============================================================================ | |||||
| import numpy as np | |||||
| import matplotlib.image as mp | |||||
| from mindspore import context, Tensor | |||||
| import mindspore | |||||
| from mindspore.dataset.vision.py_transforms import ToTensor | |||||
| import mindspore.dataset.vision.py_transforms as P | |||||
| from mindspore.dataset.vision.py_transforms import ToPIL as ToPILImage | |||||
| from FaceRecognition.eval import get_net | |||||
| import AFR | |||||
| context.set_context(mode=context.GRAPH_MODE, device_target="GPU") | |||||
| imageize = ToPILImage() | |||||
| if __name__ == '__main__': | |||||
| """ | |||||
| The input image, target image and adversarial image are tested using the FaceRecognition model. | |||||
| """ | |||||
| image = AFR.load_data('opencv_photo/adv_input') | |||||
| inputs = AFR.load_data('opencv_photo/input/') | |||||
| targets = AFR.load_data('opencv_photo/target/') | |||||
| tensorize = ToTensor() | |||||
| normalize = P.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) | |||||
| expand_dims = mindspore.ops.ExpandDims() | |||||
| MEAN = Tensor([0.485, 0.456, 0.406]) | |||||
| STD = Tensor([0.229, 0.224, 0.225]) | |||||
| resnet = get_net() | |||||
| image = mp.imread("./对抗图像.jpg") | |||||
| adv = Tensor(normalize(tensorize(image))) | |||||
| input_tensor = Tensor(normalize(tensorize(inputs[0]))) | |||||
| target_tensor = Tensor(normalize(tensorize(targets[0]))) | |||||
| adversarial_emb = resnet(expand_dims(adv, 0)) | |||||
| input_emb = resnet(expand_dims(input_tensor, 0)) | |||||
| target_emb = resnet(expand_dims(target_tensor, 0)) | |||||
| adversarial = np.argmax(adversarial_emb.asnumpy()) | |||||
| target = np.argmax(target_emb.asnumpy()) | |||||
| input = np.argmax(input_emb.asnumpy()) | |||||
| print("input:", input) | |||||
| print("input_confidence:", input_emb.asnumpy()[0][input]) | |||||
| print("================================") | |||||
| print("adversarial:", adversarial) | |||||
| print("adversarial_confidence:", adversarial_emb.asnumpy()[0][adversarial]) | |||||
| print("Confidence changes for input:", adversarial_emb.asnumpy()[0][input]) | |||||
| print("================================") | |||||
| print("input:%d, target:%d, adversarial:%d" % (input, target, adversarial)) | |||||