mindarmour.adv_robustness.evaluations

此模块包括各种指标，用于评估攻击或防御的结果。

class mindarmour.adv_robustness.evaluations.AttackEvaluate(inputs, labels, adv_inputs, adv_preds, targeted=False, target_label=None)

攻击方法的评估指标。

参数：

• inputs (numpy.ndarray) - 原始样本。

• labels (numpy.ndarray) - 原始样本的one-hot格式标签。

• adv_inputs (numpy.ndarray) - 从原始样本生成的对抗样本。

• adv_preds (numpy.ndarray) - 对对抗样本的对所有标签的预测概率。

• targeted (bool) - 如果为 True，则为目标攻击。如果为 False，则为无目标攻击。默认值：False。

• target_label (numpy.ndarray) - 对抗样本的目标标签，是大小为adv_inputs.shape[0]的一维。默认值：None。

异常：

• ValueError - 如果 targeted 为 True 时， target_label 为 None。

样例：

>>> from mindarmour.adv_robustness.evaluations import AttackEvaluate
>>> x = np.random.normal(size=(3, 512, 512, 3))
>>> adv_x = np.random.normal(size=(3, 512, 512, 3))
>>> y = np.array([[0.1, 0.1, 0.2, 0.6],
...               [0.1, 0.7, 0.0, 0.2],
...               [0.8, 0.1, 0.0, 0.1]])
>>> adv_y = np.array([[0.1, 0.1, 0.2, 0.6],
...                   [0.1, 0.0, 0.8, 0.1],
...                   [0.0, 0.9, 0.1, 0.0]])
>>> attack_eval = AttackEvaluate(x, y, adv_x, adv_y)
>>> mr = attack_eval.mis_classification_rate()
>>> acac = attack_eval.avg_conf_adv_class()
>>> l_0, l_2, l_inf = attack_eval.avg_lp_distance()
>>> ass = attack_eval.avg_ssim()
>>> nte = attack_eval.nte()
>>> actc = attack_eval.avg_conf_true_class()

avg_conf_adv_class()

计算对抗类的平均置信度（ACAC）。

返回：

• float - 范围在（0,1）之间。值越高，攻击就越成功。

avg_conf_true_class()

计算真类的平均置信度（ACTC）。

返回：

• float - 范围在（0,1）之间。值越低，攻击就越成功。

avg_lp_distance()

计算平均lp距离（lp-dist）。

返回：

• float - 返回所有成功对抗样本的平均’l0’、’l2’或’linf’距离，返回值包括以下情况：

  • 如果返回值 \(>=\) 0，则为平均lp距离。值越低，攻击就越成功。

  • 如果返回值为-1，则没有成功的对抗样本。

avg_ssim()

计算平均结构相似性（ASS）。

返回：

• float - 平均结构相似性。

  • 如果返回值在（0,1）之间，则值越高，攻击越成功。

  • 如果返回值为-1，则没有成功的对抗样本。

mis_classification_rate()

计算错误分类率（MR）。

返回：

• float - 范围在（0,1）之间。值越高，攻击就越成功。

nte()

计算噪声容量估计（NTE）。

参考文献：Towards Imperceptible and Robust Adversarial Example Attacks against Neural Networks。

返回：

• float - 范围在（0,1）之间。值越高，攻击就越成功。

class mindarmour.adv_robustness.evaluations.BlackDefenseEvaluate(raw_preds, def_preds, raw_query_counts, def_query_counts, raw_query_time, def_query_time, def_detection_counts, true_labels, max_queries)

反黑盒防御方法的评估指标。

参数：

• raw_preds (numpy.ndarray) - 原始模型上特定样本的预测结果。

• def_preds (numpy.ndarray) - 原始防御模型上特定样本的预测结果。

• raw_query_counts (numpy.ndarray) - 在原始模型上生成对抗样本的查询数，原始模型是大小是与raw_preds.shape[0]的第一纬度相同。对于良性样本，查询计数必须设置为 0。

• def_query_counts (numpy.ndarray) - 在防御模型上生成对抗样本的查询数，原始模型是大小是与raw_preds.shape[0]的第一纬度相同。对于良性样本，查询计数必须设置为 0。

• raw_query_time (numpy.ndarray) - 在原始模型上生成对抗样本的总持续时间，该样本是大小是与raw_preds.shape[0]的第一纬度。

• def_query_time (numpy.ndarray) - 在防御模型上生成对抗样本的总持续时间，该样本是大小是与raw_preds.shape[0]的第一纬度。

• def_detection_counts (numpy.ndarray) - 每次对抗样本生成期间检测到的查询总数，大小是与raw_preds.shape[0]的第一纬度。对于良性样本，如果查询被识别为可疑，则将 def_detection_counts 设置为 1，否则将其设置为 0。

• true_labels (numpy.ndarray) - 大小是与raw_preds.shape[0]的第一纬度真标签。

• max_queries (int) - 攻击预算，最大查询数。

样例：

>>> from mindarmour.adv_robustness.evaluations import BlackDefenseEvaluate
>>> raw_preds = np.array([[0.1, 0.1, 0.2, 0.6],
...                       [0.1, 0.7, 0.0, 0.2],
...                       [0.8, 0.1, 0.0, 0.1]])
>>> def_preds = np.array([[0.1, 0.1, 0.1, 0.7],
...                       [0.1, 0.6, 0.2, 0.1],
...                       [0.1, 0.2, 0.1, 0.6]])
>>> raw_query_counts = np.array([0,20,10])
>>> def_query_counts = np.array([0,50,60])
>>> raw_query_time = np.array([0.1, 2, 1])
>>> def_query_time = np.array([0.2, 6, 5])
>>> def_detection_counts = np.array([1, 5, 10])
>>> true_labels = np.array([3, 1, 0])
>>> max_queries = 100
>>> def_eval = BlackDefenseEvaluate(raw_preds,
...                             def_preds,
...                             raw_query_counts,
...                             def_query_counts,
...                             raw_query_time,
...                             def_query_time,
...                             def_detection_counts,
...                             true_labels,
...                             max_queries)
>>> qcv = def_eval.qcv()
>>> asv = def_eval.asv()
>>> fpr = def_eval.fpr()
>>> qrv = def_eval.qrv()

asv()

计算攻击成功率方差（ASV）。

返回：

• float - 值越低，防守就越强。如果num_adv_samples=0，则返回-1。

fpr()

计算基于查询的检测器的假正率（FPR）。

返回：

• float - 值越低，防御的可用性越高。如果num_adv_samples=0，则返回-1。

qcv()

计算查询计数方差（QCV）。

返回：

• float - 值越高，防守就越强。如果num_adv_samples=0，则返回-1。

qrv()

计算良性查询响应时间方差（QRV）。

返回：

• float - 值越低，防御的可用性越高。如果num_adv_samples=0，则返回-1。

class mindarmour.adv_robustness.evaluations.DefenseEvaluate(raw_preds, def_preds, true_labels)

防御方法的评估指标。

参数：

• raw_preds (numpy.ndarray) - 原始模型上某些样本的预测结果。

• def_preds (numpy.ndarray) - 防御模型上某些样本的预测结果。

• true_labels (numpy.ndarray) - 样本的ground-truth标签，一个大小为ground-truth的一维数组。

样例：

>>> from mindarmour.adv_robustness.evaluations import DefenseEvaluate
>>> raw_preds = np.array([[0.1, 0.1, 0.2, 0.6],
...                       [0.1, 0.7, 0.0, 0.2],
...                       [0.8, 0.1, 0.0, 0.1]])
>>> def_preds = np.array([[0.1, 0.1, 0.1, 0.7],
...                       [0.1, 0.6, 0.2, 0.1],
...                       [0.1, 0.2, 0.1, 0.6]])
>>> true_labels = np.array([3, 1, 0])
>>> def_eval = DefenseEvaluate(raw_preds,
...                            def_preds,
...                            true_labels)
>>> cav = def_eval.cav()
>>> crr = def_eval.crr()
>>> csr = def_eval.csr()
>>> ccv = def_eval.ccv()
>>> cos = def_eval.cos()

cav()

计算分类精度方差（CAV）。

返回：

• float - 值越高，防守就越成功。

ccv()

计算分类置信度方差（CCV）。

返回：

• float - 值越低，防守就越成功。如果返回值== -1，则说明样本数量为0。

cos()

参考文献：Calculate classification output stability (COS)。

返回：

• float - 如果返回值>=0，则是有效的防御。值越低，防守越成功。如果返回值== -1, 则说明样本数量为0。

crr()

计算分类校正率（CRR）。

返回：

• float - 值越高，防守就越成功。

csr()

计算分类牺牲比（CSR），越低越好。

返回：

• float - 值越低，防守就越成功。

class mindarmour.adv_robustness.evaluations.NeuronMetric(model, inputs, adv_inputs, hook_names)

神经元敏感度，通过计算神经元在输入正常样本和对抗样本时的激活值变化，来衡量神经元的敏感度。

参数：

• model (mindspore.nn.Cell) - 待测量神经元敏感度的模型本身。

• inputs (mindspore.Tensor) - 所使用数据的原始样本。

• adv_inputs (mindspore.Tensor) - 所使用数据的对抗样本，需要和原始样本一一对应。

• hook_names (List[str]) - 所需要计算神经元敏感度的层的名字。

异常：

• ValueError - 模型中间层输出的shape维度数目小于等于1。

样例：

>>> from mindarmour.adv_robustness.evaluations import NeuronMetric
>>> from mindspore import ops
>>> # Refer to https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
>>> model = LeNet()
>>> x = ops.randn((10, 3, 32, 32))
>>> adv_x = ops.randn((10, 3, 32, 32))
>>> layers = ["conv1", "conv2", "fc1", "fc2"]
>>> neuron_metric = NeuronMetric(model, x, adv_x, layers)
>>> nsense = neuron_metric.neuron_sensitivity()

neuron_sensitivity()

计算并返回神经元敏感度。

返回：

• nsense - 神经元敏感度的字典，包含每个层的名字和层的神经元对应的神经元敏感度。

class mindarmour.adv_robustness.evaluations.RadarMetric(metrics_name, metrics_data, labels, title, scale='hide')

雷达图，通过多个指标显示模型的鲁棒性。

参数：

• metrics_name (Union[tuple, list]) - 要显示的度量名称数组。每组值对应一条雷达曲线。

• metrics_data (numpy.ndarray) - 多个雷达曲线的每个度量的（归一化）值，如[[0.5, 0.8, …], [0.2,0.6,…], …]。

• labels (Union[tuple, list]) - 所有雷达曲线的图例。

• title (str) - 图表的标题。

• scale (str) - 用于调整轴刻度的标量，如 'hide'、'norm'、'sparse'、'dense'。默认值：'hide'。

异常：

• ValueError - scale 值不为 'hide'、'norm'、'sparse'、'dense'。

样例：

>>> from mindarmour.adv_robustness.evaluations import RadarMetric
>>> metrics_name = ['MR', 'ACAC', 'ASS', 'NTE', 'ACTC']
>>> def_metrics = [0.9, 0.85, 0.6, 0.7, 0.8]
>>> raw_metrics = [0.5, 0.3, 0.55, 0.65, 0.7]
>>> metrics_data = np.array([def_metrics, raw_metrics])
>>> metrics_labels = ['before', 'after']
>>> rm = RadarMetric(metrics_name,
...                  metrics_data,
...                  metrics_labels,
...                  title='',
...                  scale='sparse')
>>> #rm.show()

show()

显示雷达图。