Common

amp

Auto mixed precision api.

class mindnlp.common.amp.DynamicLossScaler(scale_value, scale_factor, scale_window)[源代码]

基类：LossScaler

Dynamic LossScaler

adjust(grads_finite)[源代码]: adjust scale value.

scale(inputs)[源代码]: scale inputs tensor.

unscale(inputs)[源代码]: unscale inputs tensor.

class mindnlp.common.amp.LossScaler(scale_value)[源代码]

基类：object

Basic LossScaler.

adjust(grads_finite)[源代码]: adjust scale value.

scale(inputs)[源代码]: scale inputs tensor.

unscale(inputs)[源代码]: unscale inputs tensor.

class mindnlp.common.amp.NoLossScaler[源代码]

基类：LossScaler

No LossScaler

adjust(grads_finite)[源代码]: adjust scale value.

scale(inputs)[源代码]: scale inputs tensor.

unscale(inputs)[源代码]: unscale inputs tensor.

class mindnlp.common.amp.StaticLossScaler(scale_value)[源代码]

基类：LossScaler

Static LossScaler.

adjust(grads_finite)[源代码]: adjust scale value.

scale(inputs)[源代码]: scale inputs tensor.

unscale(inputs)[源代码]: unscale inputs tensor.

mindnlp.common.amp.all_finite(inputs)[源代码]: whether all inputs tensor are finite.

mindnlp.common.amp.auto_black_list(network, black_list=None)[源代码]: auto cast based on black list

mindnlp.common.amp.auto_mixed_precision(network, amp_level='O1')[源代码]: auto mixed precision cast.

mindnlp.common.amp.auto_white_list(network, white_list=None)[源代码]: auto cast based on white list

loss

Losses

class mindnlp.common.loss.CMRC2018Loss(reduction='mean')[源代码]

基类：Cell

用于计算CMRC2018中文问答任务

参数: reduction (str) – 计算loss的方式，候选有 mean 和 sum. 默认：mean

construct(target_start, target_end, context_len, pred_start, pred_end)[源代码]

计算 CMRC2018Loss

参数

target_start (Tensor) – size: batch_size, dtype: int.
target_end (Tensor) – size: batch_size, dtype: int.
context_len (Tensor) – size: batch_size, dtype: float.
pred_start (Tensor) – size: batch_size*max_len, dtype: float.
pred_end (Tensor) – size: batch_size*max_len, dtype: float.

返回

Tensor, 计算后的 CMRC2018Loss

抛出

ValueError – 计算方式 reduction 没有选择 sum 或 mean

示例

>>> cmrc_loss = CMRC2018Loss()
>>> tensor_a = mindspore.Tensor(np.array([1, 2, 1]), mindspore.int32)
>>> tensor_b = mindspore.Tensor(np.array([2, 1, 2]), mindspore.int32)
>>> my_context_len = mindspore.Tensor(np.array([2., 1., 2.]), mindspore.float32)
>>> tensor_c = mindspore.Tensor(np.array([
>>>     [0.1, 0.2, 0.1],
>>>     [0.1, 0.2, 0.1],
>>>     [0.1, 0.2, 0.1]
>>> ]), mindspore.float32)
>>> tensor_d = mindspore.Tensor(np.array([
>>>     [0.2, 0.1, 0.2],
>>>     [0.2, 0.1, 0.2],
>>>     [0.2, 0.1, 0.2]
>>> ]), mindspore.float32)
>>> my_loss = cmrc_loss(tensor_a, tensor_b, my_context_len, tensor_c, tensor_d)
>>> print(my_loss)

class mindnlp.common.loss.RDropLoss(reduction='none')[源代码]

基类：Cell

R-Drop Loss 的实现。更多关于R-drop的信息请参考这篇文章：https://arxiv.org/abs/2106.14448

原始实现请参考这里的代码：https://github.com/dropreg/R-Drop

参数

reduction (str) –

计算loss的方式，候选有 none, batchmean, mean, sum。默认: none

mean：将返回降维后的loss均值
batchmean：将返回降维后的loss批次均值
sum：将返回降维后的loss求和
none：不采取任何降维方法

construct(p, q, pad_mask=None)[源代码]

返回p和q的rdrop loss

参数

p (Tensor) – 训练样本的第一次前向向量
q (Tensor) – 训练样本的第二次前向向量
pad_mask (Tensor) – 包含要索引的二进制掩码的张量Tensor，其数据类型为 bool。默认: None

返回

Tensor， p和q的rdrop loss

抛出

ValueError – 计算方式 reduction 不是 sum , mean , batchmean 或 none 的其中一个。

示例

>>> r_drop_loss = RDropLoss()
>>> p = Tensor(np.array([1., 0. , 1.]), mindspore.float32)
>>> q = Tensor(np.array([0.2, 0.3 , 1.1]), mindspore.float32)
>>> loss = r_drop_loss(p, q)
>>> print(loss)
0.100136

metrics

metrics函数

mindnlp.common.metrics.accuracy(preds, labels)[源代码]

计算准确率accuracy。函数如下所示：

\[\text{ACC} =\frac{\text{TP} + \text{TN}} {\text{TP} + \text{TN} + \text{FP} + \text{FN}}\]

其中`ACC`是准确率accuracy，`TP`是正确预测的正样本数量，`TN`是正确预测的负样本数量，`FP`是错误预测的正样本数量，`FN`是错误预测的负样本数量。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。范围在`[0，1]`中的浮点数列表，在大多数情况下（不严格要求），shape是`(N, C)`，其中`N`是样本数，`C`是类别数。
labels (Union[Tensor, list, np.ndarray]) – 真实值。必须是one-hot编码格式，shape为`(N, C)`，或能够转换为one-hot格式，shape为`(N,)`。

返回

acc (float) - 计算得到的结果。

抛出

RuntimeError – 如果样本数为0。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import accuracy
>>> preds = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> labels = Tensor(np.array([1, 0, 1]), mindspore.int32)
>>> acc = accuracy(preds, labels)
>>> print(acc)
0.6666666666666666

mindnlp.common.metrics.bleu(cand, ref_list, n_size=4, weights=None)[源代码]

计算BLEU分数。BLEU (bilingual evaluation understudy)是一种用于评价机器翻译文本质量的指标。它使用一种精确度precision的修正形式来比较候选翻译与多个参考翻译。函数如下所示：

\[ \begin{align}\begin{aligned}\begin{split}BP & = \begin{cases} 1, & \text{if }c>r \\ e_{1-r/c}, & \text{if }c\leq r \end{cases}\end{split}\\BLEU & = BP\exp(\sum_{n=1}^N w_{n} \log{p_{n}})\end{aligned}\end{align} \]

其中`c`是候选句子的长度，`r`是参考句子的长度。

参数

cand (list) – 分词后的候选句子列表。
ref_list (list) – 分词后的真实句子列表。
n_size (int) – N_gram值的范围从1到4。默认：4。
weights (Union[list, None]) – 每个gram的precision的权重。默认为None。

返回

bleu_score (float) - 计算得到的结果。

抛出

ValueError – 如果`n_size`的值范围不是从1到4。
ValueError – 如果`cand`和`ref_list`的长度不相等
ValueError – 如果`weights`的长度不等于`n_size`。

示例

>>> from mindnlp.common.metrics import bleu
>>> cand = [["The", "cat", "The", "cat", "on", "the", "mat"]]
>>> ref_list = [[["The", "cat", "is", "on", "the", "mat"],
                ["There", "is", "a", "cat", "on", "the", "mat"]]]
>>> bleu_score = bleu(cand, ref_list)
>>> print(bleu_score)
0.46713797772820015

mindnlp.common.metrics.confusion_matrix(preds, labels, class_num=2)[源代码]

计算混淆矩阵confusion matrix。混淆矩阵confusion matrix被广泛用于评价分类模型的性能，包括二分类和多分类。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。一个浮点数列表，其shape为`(N, C)`或`(N,)`。
labels (Union[Tensor, list, np.ndarray]) – 真实值。shape为`(N,)`。
class_num (int) – 数据集中类的数量。默认：2。

返回

conf_mat (np.ndarray) - 计算得到的结果。

抛出

ValueError – 如果`preds`和`labels`没有有效的维度。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import confusion_matrix
>>> preds = Tensor(np.array([1, 0, 1, 0]))
>>> labels = Tensor(np.array([1, 0, 0, 1]))
>>> conf_mat = confusion_matrix(preds, labels)
>>> print(conf_mat)
[[1. 1.]
 [1. 1.]]

mindnlp.common.metrics.distinct(cand_list, n_size=2)[源代码]

计算Distinct-N。Distinct-N是一种测量句子多样性的指标。它关注一个句子中不同n-gram的数量。不同n-gram的数量越多，文本的多样性越高。函数如下所示：

参数

cand_list (list) – 分词后的候选句子列表。
n_size (int) – N_gram值。默认：2。

返回

distinct_score (float) - 计算得到的结果。

示例

>>> from mindnlp.common.metrics import distinct
>>> cand_list = ["The", "cat", "The", "cat", "on", "the", "mat"]
>>> distinct_score = distinct(cand_list)
>>> print(distinct_score)
0.8333333333333334

mindnlp.common.metrics.em_score(preds, examples)[源代码]

计算exact match (EM)分数。这个指标测量预测值精准匹配任一真实值的百分比。

参数

preds (Union[str, list]) – 预测值。
examples (list) – 真实值。

返回

exact_match (float) - 计算得到的结果。

抛出

RuntimeError – 如果`preds`和`examples`长度不同。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import em_score
>>> preds = "this is the best span"
>>> examples = ["this is a good span", "something irrelevant"]
>>> exact_match = em_score(preds, examples)
>>> print(exact_match)
0.0

mindnlp.common.metrics.f1_score(preds, labels)[源代码]

计算F1分数。Fbeta分数是precision和recall的加权平均，F1分数是Fbeta的一种特殊情况，此时beta为1。函数如下所示：

\[F_1=\frac{2\cdot TP}{2\cdot TP + FN + FP}\]

其中`TP`是正确预测的正样本数量，`FN`是错误预测的负样本数量，`FP`是错误预测的正样本数量。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。范围在`[0，1]`中的浮点数列表，在大多数情况下（不严格要求），shape是`(N, C)`，其中`N`是样本数，`C`是类别数。
labels (Union[Tensor, list, np.ndarray]) – 真实值。必须是one-hot编码格式，shape为`(N, C)`，或能够转换为one-hot格式，shape为`(N,)`。

返回

f1_s (np.ndarray) - 计算得到的结果。

抛出

ValueError – 如果`preds`和`labels`没有相同数量的类。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import f1_score
>>> preds = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> labels = Tensor(np.array([1, 0, 1]))
>>> f1_s = f1_score(preds, labels)
>>> print(f1_s)
[0.6666666666666666 0.6666666666666666]

mindnlp.common.metrics.matthews_correlation(preds, labels)[源代码]

计算Matthews相关系数(MCC)。MCC本质上是观测的和预测的二分类之间的相关系数；它返回了一个介于-1和+1之间的值。系数+1表示一次完美的预测，0不比随机预测好，−1表示预测值和观测值完全不同。函数如下所示：

\[MCC=\frac{TP \times TN-FP \times FN}{\sqrt{(TP+FP)(TP+FN)(TN+FP)(TN+FN)}}\]

其中`TP`是正确预测的正样本数，`TN`是正确预测的负样本数，`FN`是错误预测的负样本数，`FP`是错误预测的正样本数。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。浮点数列表，大多数情况下（不严格要求），shape是`(N, C)`，其中`N`是样本数，`C`是类别数。
labels (Union[Tensor, list, np.ndarray]) – 真实值。必须是one-hot编码格式，shape为`(N, C)`，或能够转换为one-hot格式，shape为`(N,)`。

返回

m_c_c (float) - 计算得到的结果。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import matthews_correlation
>>> preds = [[0.8, 0.2], [-0.5, 0.5], [0.1, 0.4], [0.6, 0.3], [0.6, 0.3]]
>>> labels = [0, 1, 0, 1, 0]
>>> m_c_c = matthews_correlation(preds, labels)
>>> print(m_c_c)
0.16666666666666666

mindnlp.common.metrics.pearson_correlation(preds, labels)[源代码]

计算Pearson相关系数(PCC)。PCC是两组数据之间线性相关系数的测量方式。它是两个变量之间的协方差之比，他们标准差的乘积；因此，它本质上是协方差的归一化测量，结果值总在−1和1之间。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。浮点数列表，shape为`(N, 1)`。
labels (Union[Tensor, list, np.ndarray]) – 真实值。浮点数列表，shape是`(N, 1)`。

返回

p_c_c (float) - 计算得到的结果。

抛出

RuntimeError – 如果`preds`和`labels`长度不同。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import pearson_correlation
>>> preds = Tensor(np.array([[0.1], [1.0], [2.4], [0.9]]), mindspore.float32)
>>> labels = Tensor(np.array([[0.0], [1.0], [2.9], [1.0]]), mindspore.float32)
>>> p_c_c = pearson_correlation(preds, labels)
>>> print(p_c_c)
0.9985229081857804

mindnlp.common.metrics.perplexity(preds, labels, ignore_label=None)[源代码]

计算perplexity。Perplexity衡量概率模型预测样本的能力。低的perplexity说明模型善于预测样本。函数如下所示：

\[PP(W)=P(w_{1}w_{2}...w_{N})^{-\frac{1}{N}}=\sqrt[N]{\frac{1}{P(w_{1}w_{2}...w_{N})}}\]

其中`w`表示语料库中的词。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。范围在`[0，1]`中的浮点数列表，在大多数情况下（不严格要求），shape是`(N, C)`，其中`N`是样本数，`C`是类别数。
labels (Union[Tensor, list, np.ndarray]) – 真实值。必须是one-hot编码格式，shape为`(N, C)`，或能够转换为one-hot格式，shape为`(N,)`。
ignore_label (Union[int, None]) – 计数时要忽略的无效标签的索引。如果设置为`None`，它意味着没有无效标签。默认：None。

返回

ppl (float) - 计算得到的结果。

抛出

RuntimeError – 如果`preds`和`labels`长度不同。
RuntimeError – 如果`pred`和`label`有不同的shape。
RuntimeError – 如果样本数为0。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import perplexity
>>> preds = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> labels = Tensor(np.array([1, 0, 1]), mindspore.int32)
>>> ppl = perplexity(preds, labels, ignore_label=None)
>>> print(ppl)
2.231443166940565

mindnlp.common.metrics.precision(preds, labels)[源代码]

计算精确度precision。精确度precision（也称为正预测值）是预测的正样本中的实际正样本比例。它只被用来评价二分类任务的精确度precision分数。函数如下所示：

\[\text{Precision} =\frac{\text{TP}} {\text{TP} + \text{FP}}\]

其中`TP`是正确预测的正样本数，`FP`是错误预测的正样本数。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。范围在`[0，1]`中的浮点数列表，在大多数情况下（不严格要求），shape是`(N, C)`，其中`N`是样本数，`C`是类别数。
labels (Union[Tensor, list, np.ndarray]) – 真实值。必须是one-hot编码格式，shape为`(N, C)`，或能够转换为one-hot格式，shape为`(N,)`。

返回

prec (np.ndarray) - 计算得到的结果。

抛出

ValueError – 如果`preds`和`labels`没有相同数量的类。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import precision
>>> preds = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> labels = Tensor(np.array([1, 0, 1]), mindspore.int32)
>>> prec = precision(preds, labels)
>>> print(prec)
[0.5 1. ]

mindnlp.common.metrics.recall(preds, labels)[源代码]

计算召回率recall。召回率也指真的正确率或灵敏度。函数如下所示：

\[\text{Recall} =\frac{\text{TP}} {\text{TP} + \text{FN}}\]

其中`TP`是正确预测的正样本数，`FN`是错误预测的负样本数。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。范围在`[0，1]`中的浮点数列表，在大多数情况下（不严格要求），shape是`(N, C)`，其中`N`是样本数，`C`是类别数。
labels (Union[Tensor, list, np.ndarray]) – 真实值。必须是one-hot编码格式，shape为`(N, C)`，或能够转换为one-hot格式，shape为`(N,)`。

返回

rec (np.ndarray) - 计算得到的结果。

抛出

ValueError – 如果`preds`和`labels`没有相同数量的类。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import recall
>>> preds = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> labels = Tensor(np.array([1, 0, 1]), mindspore.int32)
>>> rec = recall(preds, labels)
>>> print(rec)
[1. 0.5]

mindnlp.common.metrics.rouge_l(cand_list, ref_list, beta=1.2)[源代码]

计算ROUGE-L分数。ROUGE (Recall-Oriented Understudy for Gisting Evaluation)是一组用于评估自动摘要和机器翻译模型的指标。ROUGE-L基于最长公共子序列(LCS)计算。函数如下所示：

\[ \begin{align}\begin{aligned}R_{l c s}=\frac{L C S(X, Y)}{m}\\p_{l c s}=\frac{L C S(X, Y)}{n}\\F_{l c s}=\frac{\left(1+\beta^{2}\right) R_{l c s} P_{l c s}}{R_{l c s}+\beta^{2} P_{l c s}}\end{aligned}\end{align} \]

其中`X`是候选句子，`Y`是参考句子。`m`和`n`分别表示`X`和`Y`的长度。`LCS`意味着最长公共子序列。

参数

cand_list (list) – 分词后的候选句子列表。
ref_list (list) – 分词后的真实句子列表。
beta (float) – 一个决定召回率recall权重的超参数。默认：1.2。

返回

rougel_score (float) - 计算得到的结果。

示例

>>> from mindnlp.common.metrics import rouge_l
>>> cand_list = ["The","cat","The","cat","on","the","mat"]
>>> ref_list = [["The","cat","is","on","the","mat"],
                ["There","is","a","cat","on","the","mat"]]
>>> rougel_score = rouge_l(cand_list, ref_list)
>>> print(rougel_score)
0.7800511508951408

mindnlp.common.metrics.rouge_n(cand_list, ref_list, n_size=1)[源代码]

计算ROUGE-N分数。ROUGE(Recall-Oriented Understudy for Gisting Evaluation)是一组用于评估自动摘要和机器翻译模型的指标。ROUGE-N指的是候选句子和参考摘要之间的n-gram重叠。

参数

cand_list (list) – 分词后的候选句子列表。
ref_list (list) – 分词后的真实句子列表。
n_size (int) – N_gram值。默认：1。

返回

rougen_score (float) - 计算得到的结果。

抛出

RuntimeError – 如果参考句子的长度为0。

示例

>>> from mindnlp.common.metrics import rouge_n
>>> cand_list = ["the", "cat", "was", "found", "under", "the", "bed"]
>>> ref_list = [["the", "cat", "was", "under", "the", "bed"]]
>>> rougen_score = rouge_n(cand_list, ref_list, 2)
>>> print(rougen_score)
0.8

mindnlp.common.metrics.spearman_correlation(preds, labels)[源代码]

计算斯皮尔曼秩相关系数（Spearman’s rank correlation coefficient，SRCC）。它是一种非参数的秩相关性（两个变量的秩之间的统计相关性）度量。它使用单调函数，评估了模型描述两个变量之间的关系的能力。如果不存在重复的数值，当每一个变量都是另一个变量的一个完美的单调函数时，此时的斯皮尔曼相关系数是完美的，为+1或−1。

参数

preds (Union[Tensor, list, np.ndarray]) – 预测值。浮点数列表，shape为`(N, 1)`。
labels (Union[Tensor, list, np.ndarray]) – 真实值。浮点数列表，shape是`(N, 1)`。

返回

s_r_c_c (float) - 计算得到的结果。

抛出

RuntimeError – 如果`preds`和`labels`长度不同。

示例

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor
>>> from mindnlp.common.metrics import spearman_correlation
>>> preds = Tensor(np.array([[0.1], [1.0], [2.4], [0.9]]), mindspore.float32)
>>> labels = Tensor(np.array([[0.0], [1.0], [2.9], [1.0]]), mindspore.float32)
>>> s_r_c_c = spearman_correlation(preds, labels)
>>> print(s_r_c_c)
1.0