# 金融 / 专题函数 / 机器学习 / 机器学习算法评价方法 / 分类算法评价指标

## `accuracy_score(y_true, y_pred, normalize, sample_weight)`

声明：function

计算准确率

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数            | 类型  | 说明                                                            |
| --------------- | ----- | --------------------------------------------------------------- |
| `y_true`        | array | 数组，真实值序列                                                |
| `y_pred`        | array | 数组，预测值序列                                                |
| `normalize`     | bool  | 布尔型，是否转为准确率，默认为真；为假时返回 两个序列相等的个数 |
| `sample_weight` | array | 数组，样本权重                                                  |

返回：float

### 示例

范例01：准确率 0.5789

```tsl
y_true := array("cat", "ant", "cat", "cat", "ant", "bird");
y_pred := array("ant", "ant", "cat", "cat", "ant", "cat");
sample_weight := array(1, 1.5, 2, 1, 1, 3);
echo Accuracy_Score(y_true, y_pred, False); // 相等元素个数 5.5
return Accuracy_Score(y_true, y_pred, true, sample_weight);
// 准确率 0.5789
```

范例02：y_true 为矩阵时，一行 每个元素 都相等 算一个

```tsl
// y_true 为矩阵时，一行 每个元素 都相等 算一个
y_true := array((0, 1), (1, 1));
y_pred := array((1, 1), (1, 1));
return Accuracy_Score(y_true, y_pred);   // 准确率 0.5
```

## `auc(x, y)`

声明：function

计算auc，根据roc_curve计算出来的fpr和tpr序列值计算AUC值

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 AUC -->

| 参数 | 类型  | 说明    |
| ---- | ----- | ------- |
| `x`  | array | x坐标点 |
| `y`  | array | y坐标点 |

返回：real

### 示例

范例01：调用函数

```tsl
y_true := array(1, 1, 2, 2, 1, 2, 1, 2);
y_score := array(0.1, 0.4, 0.35, 0.8, 0.5, 0.7, 0.45, 0.6);
ret := roc_curve(y_true, y_score, 2);
fpr := ret[0];
tpr := ret[1];
return auc(fpr, tpr); // 输出：0.8125
```

## `balanced_accuracy_score(y_true, y_pred, sample_weight, adjusted)`

声明：function

计算单标签分类模型的平衡准确率，适用于单标签模型

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数            | 类型  | 说明                                                      |
| --------------- | ----- | --------------------------------------------------------- |
| `y_true`        | array | 一维数组，真实标签                                        |
| `y_pred`        | array | 一维数组，预测标签                                        |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重                          |
| `adjusted`      | bool  | 布尔值，是否调整准确率，去掉随机部分，默认false，不作调整 |

返回：float

### 示例

范例01：只提供y_true和y_pred

```tsl
// 只提供y_true和y_pred
y_true := array(0, 1, 0, 0, 1, 0);
y_pred := array(0, 1, 0, 0, 0, 1);
return balanced_accuracy_score(y_true, y_pred);  // 输出：0.625
```

范例02：指定sample_weight

```tsl
// 指定sample_weight
y_true := array(0, 1, 0, 0, 1, 0);
y_pred := array(0, 1, 0, 0, 0, 1);
sample_weight := array(1, 1, 1, 1, 1, 2);
return balanced_accuracy_score(y_true, y_pred, sample_weight); // 输出：0.55
```

范例03：设定adjusted为真，计算调整后平衡准确率

```tsl
// 设定adjusted为真，计算调整后平衡准确率
y_true := array(0, 1, 0, 0, 1, 0);
y_pred := array(0, 1, 0, 0, 0, 1);
adjusted := true;
return balanced_accuracy_score(y_true, y_pred, nil, adjusted);  // 输出：0.25
```

## `cohen_kappa_score(y_1, y_2, labels, weights, sample_weight)`

声明：function

返回衡量单标签分类模型的分类精度的kappa系数，适用于单标签二分类和多分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 返回 获取 -->

| 参数            | 类型   | 说明                                                                       |
| --------------- | ------ | -------------------------------------------------------------------------- |
| `y_1`           | array  | 一维数组，真实标签                                                         |
| `y_2`           | array  | 一维数组，预测标签，y1和y2交换顺序不影响计算结果                           |
| `labels`        | array  | 一维数组，选择的标签集，默认是y1和y2出现过的标签                           |
| `weights`       | string | 字符串，kappa系数的惩罚权重，可选array(nil,'linear','quadratic');默认是nil |
| `sample_weight` | array  | 一维数组，样本权重，默认是等权重，全一数组                                 |

返回：float

### 示例

范例01：只提供y1和y2

```tsl
// 只提供y1和y2
y_true := array(2, 0, 2, 2, 0, 1);
y_pred := array(0, 0, 2, 2, 0, 2);
return cohen_kappa_score(y_true, y_pred);  // 输出：0.4285
```

范例02：指定labels，表示只从计算指定的的标签

```tsl
// 指定labels，表示只从计算指定的的标签
y_true := array(2, 0, 2, 2, 0, 1);
y_pred := array(0, 0, 2, 2, 0, 2);
labels := array(0, 2);
return cohen_kappa_score(y_true, y_pred, labels);  // 输出：0.6153
```

范例03：指定weights

```tsl
// 指定weights
y_true := array(2, 0, 2, 2, 0, 1);
y_pred := array(0, 0, 2, 2, 0, 2);
weights := "linear";
return cohen_kappa_score(y_true, y_pred, nil, weights);  // 输出：0.5
```

范例04：指定sample_weight

```tsl
// 指定sample_weight
y_true := array(2, 0, 2, 2, 0, 1);
y_pred := array(0, 0, 2, 2, 0, 2);
sample_weight := array(2, 2, 1, 2, 1, 1.5);
return cohen_kappa_score(y_true, y_pred, nil, nil, sample_weight);
// 0.3696
```

## `fbeta_score(y_true, y_pred, beta, average, labels, pos_label, sample_weight)`

声明：function

计算f_score，适用于单标签和多标签分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数            | 类型    | 说明                                                                                                                                                         |
| --------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `y_true`        | array   | 真实标签                                                                                                                                                     |
| `y_pred`        | array   | 预测标签                                                                                                                                                     |
| `beta`          | float   | beta参数，默认是1                                                                                                                                            |
| `average`       | string  | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，；计算每一个标签的precision |
| `labels`        | array   | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                               |
| `pos_label`     | integer | 正例标签，在单标签二分类时起作用，；当数据是单标签二分类时，并且average等于"binary"时有用，其他情况会被忽略                                                  |
| `sample_weight` | array   | 样本权重，默认等权重                                                                                                                                         |

返回：float

### 示例

范例01：只给y_true和y_pred，其他默认

```tsl
// 只给y_true和y_pred，其他默认
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
return fbeta_score(y_true, y_pred); // 输出：array(0.8,0.0,0.0)
```

范例02：指定beta参数：

```tsl
// 指定beta参数：
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
beta := 2;
return fbeta_score(y_true, y_pred, beta);
// array(0.9090,0.0,0.0)
```

范例03：指定labels

```tsl
// 指定labels
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
labels := Array(2, 1, 0);
return fbeta_score(y_true, y_pred, nil, nil, labels); // 输出：array(0.0,0.0,0.8)
```

范例04：单标签二分类，指定pos_label，并且指定average为"binary"，

```tsl
// 单标签二分类，指定pos_label，并且指定average为"binary"，
// 只计算正例的precision
y_true := Array(0, 1, 1, 0, 1, 1);
y_pred := Array(0, 0, 1, 0, 0, 1);
pos_label := 0;
average := "binary";
return fbeta_score(y_true, y_pred, nil, average, nil, pos_label);
// 0.6666
```

范例05：指定average，指定计算precision的平均方式

```tsl
// 指定average，指定计算precision的平均方式
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
average := "macro"; // 宏平均，先计算各标签的precision再取平均
return fbeta_score(y_true, y_pred, nil, average);
// 0.2666
```

范例06：指定sample_weight

```tsl
// 指定sample_weight
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
sample_weight := array(2.5, 2, 3, 1, 1.5, 2);
return fbeta_score(y_true, y_pred, nil, nil, nil, nil, sample_weight);
// array(0.8235,0.0,0.0)
```

## `hamming_loss(y_true, y_pred, sample_weight)`

声明：function

计算分类模型的汉明损失，适用于单标签和多标签模型，其中多标签模型数据是多维二元标签

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数            | 类型  | 说明                                                         |
| --------------- | ----- | ------------------------------------------------------------ |
| `y_true`        | array | 一维或者二维数组，真实类别，长度与样本数相等                 |
| `y_pred`        | array | 一维或者二维数组（与y_true一样），预测类别，长度与样本数相等 |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重                             |

返回：float

### 示例

范例01：单标签分类数据，y_true是一维数组

```tsl
// 单标签分类数据，y_true是一维数组
y_true := array(1, 2, 3, 4);
y_pred := array(2, 2, 3, 4);
return Hamming_loss(y_true, y_pred);  // 输出：0.75
```

范例02：单标签分类数据，y_true是一维数组，并提供sample_weight

```tsl
// 单标签分类数据，y_true是一维数组，并提供sample_weight
y_true := array(1, 2, 3, 4);
y_pred := array(2, 2, 3, 4);
sample_weight := array(1, 1.5, 2, 1.5);
return Hamming_loss(y_true, y_pred, sample_weight); // 输出：0.8333
```

范例03：多标签分类数据，y_true是二维数组

```tsl
// 多标签分类数据，y_true是二维数组
y_true := array((0, 1), (1, 1));
y_pred := zeros(2, 2);
return Hamming_loss(y_true, y_pred);  // 输出：0.25
```

范例04：多标签分类数据，y_true是二维数组，并提供sample_weight

```tsl
// 多标签分类数据，y_true是二维数组，并提供sample_weight
y_true := array((0, 1), (1, 1));
y_pred := zeros(2, 2);
sample_weight := array(0.5, 1);
return Hamming_loss(y_true, y_pred, sample_weight);  // 输出：0.1666
```

## `ks_curve(y_true, y_score, pos_label, sample_weight, drop_intermediate)`

声明：function

计算K-S曲线序列值，使用单标签二分类和多分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数                | 类型    | 说明                              |
| ------------------- | ------- | --------------------------------- |
| `y_true`            | array   | 真实标签                          |
| `y_score`           | array   | 预测输出概率                      |
| `pos_label`         | integer | 正例标签，默认是1，多分类必须提供 |
| `sample_weight`     | array   | 样本权重，默认等权重              |
| `drop_intermediate` | bool    | 是否去掉无用点，默认为真          |

返回：array

### 示例

范例01：只给y_true和y_pred，只有二分类时可以允许

```tsl
// 只给y_true和y_pred，只有二分类时可以允许
y_true := array(0, 1, 0, 0);
y_pred := array(0.1, 0.4, 0.35, 0.8);
return ks_curve(y_true, y_pred);
```

范例02：多分类是必须指定pos_label

```tsl
// 多分类是必须指定pos_label
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
return ks_curve(y_true, y_pred, pos_label);
```

范例03：指定sample_weight

```tsl
// 指定sample_weight
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
sample_weight := array(1, 2, 2.5, 1.3);
return ks_curve(y_true, y_pred, pos_label, sample_weight);
```

范例04：drop_intermediate为假时，不去掉无用点，使用_binary_clf_curve返回的原序列值

```tsl
// drop_intermediate为假时，不去掉无用点，使用_binary_clf_curve返回的原序列值
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
drop_intermediate := false;
return ks_curve(y_true, y_pred, pos_label, nil, drop_intermediate);
```

## `matthews_corrcoef(y_true, y_pred, sample_weight)`

声明：function

返回用以测量分类模型的分类性能的指标，该指标考虑了真阳性、真阴性和假阳性和假阴性，通常认为该指标是一个比较均衡的指标，适用于单标签二分类和多分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 返回 获取 -->

| 参数            | 类型  | 说明                             |
| --------------- | ----- | -------------------------------- |
| `y_true`        | array | 一维数组，真实标签               |
| `y_pred`        | array | 一维数组，预测标签               |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重 |

返回：float

### 示例

范例01：不提供sample_weight，默认等权重

```tsl
// 不提供sample_weight，默认等权重
y_true := array(1, 1, 1, -1);
y_pred := array(1, -1, 1, 1);
return matthews_corrcoef(y_true, y_pred); // 输出：-0.3333
```

范例02：提供sample_weight

```tsl
// 提供sample_weight
y_true := array(1, 1, 1, -1);
y_pred := array(1, -1, 1, 1);
sample_weight := array(2, 2, 1, 1);
return matthews_corrcoef(y_true, y_pred, sample_weight);
// -0.3162
```

## `precision_recall_curve(y_true, y_score, pos_label, sample_weight)`

声明：function

计算PRC曲线序列值，适用于单标签二分类和多分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 PRC -->

| 参数            | 类型    | 说明                              |
| --------------- | ------- | --------------------------------- |
| `y_true`        | array   | 真实标签                          |
| `y_score`       | array   | 预测输出概率                      |
| `pos_label`     | integer | 正例标签，默认是1，多分类必须提供 |
| `sample_weight` | array   | 样本权重，默认等权重              |

返回：array

### 示例

范例01：只给y_true和y_pred，只有二分类时可以允许

```tsl
// 只给y_true和y_pred，只有二分类时可以允许
y_true := array(0, 1, 0, 0);
y_pred := array(0.1, 0.4, 0.35, 0.8);
return precision_recall_curve(y_true, y_pred);
```

范例02：多分类是必须指定pos_label

```tsl
// 多分类是必须指定pos_label
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
return precision_recall_curve(y_true, y_pred, pos_label);
```

范例03：指定sample_weight

```tsl
// 指定sample_weight
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
sample_weight := array(1, 2, 2.5, 1.3);
return precision_recall_curve(y_true, y_pred, pos_label, sample_weight);
```

## `precision_score(y_true, y_pred, average, labels, pos_label, sample_weight)`

声明：function

计算precision，适用于单标签和多标签分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数            | 类型    | 说明                                                                                                                                                       |
| --------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y_true`        | array   | 真实标签                                                                                                                                                   |
| `y_pred`        | array   | 预测标签                                                                                                                                                   |
| `average`       | string  | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，计算每一个标签的precision |
| `labels`        | array   | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                             |
| `pos_label`     | integer | 正例标签，在单标签二分类时起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略                                                |
| `sample_weight` | array   | 样本权重，默认等权重                                                                                                                                       |

返回：float

### 示例

范例01：只给y_true和y_pred，其他默认

```tsl
// 只给y_true和y_pred，其他默认
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
return precision_score(y_true, y_pred);
// array(0.6666,0.0,0.0)
```

范例02：指定labels

```tsl
// 指定labels
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
labels := Array(2, 1, 0);
return precision_score(y_true, y_pred, nil, labels);
// array(0.0,0.0,0.6666)
```

范例03：单标签二分类，指定pos_label，并且指定average为"binary"，

```tsl
// 单标签二分类，指定pos_label，并且指定average为"binary"，
// 只计算正例的precision
y_true := Array(0, 1, 1, 0, 1, 1);
y_pred := Array(0, 0, 1, 0, 0, 1);
pos_label := 0;
average := "binary";
return precision_score(y_true, y_pred, average, nil, pos_label); // 输出：0.5
```

范例04：指定average，指定计算precision的平均方式

```tsl
// 指定average，指定计算precision的平均方式
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
average := "macro"; // 宏平均，先计算各标签的precision再取平均
return precision_score(y_true, y_pred, average);
// 0.2222
```

范例05：指定sample_weight

```tsl
// 指定sample_weight
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
sample_weight := array(1, 2, 3, 1, 1.5, 2);
return precision_score(y_true, y_pred, nil, nil, nil, sample_weight);
// array(0.5714,0.0,0.0)
```

## `recall_score(y_true, y_pred, average, labels, pos_label, sample_weight)`

声明：function

计算recall，适用于单标签和多标签分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 计算 求解 -->

| 参数            | 类型    | 说明                                                                                                                                                       |
| --------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y_true`        | array   | 真实标签                                                                                                                                                   |
| `y_pred`        | array   | 预测标签                                                                                                                                                   |
| `average`       | string  | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，计算每一个标签的precision |
| `labels`        | array   | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                             |
| `pos_label`     | integer | 正例标签，在单标签二分类时起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略                                                |
| `sample_weight` | array   | 样本权重，默认等权重                                                                                                                                       |

返回：float

### 示例

范例01：只给y_true和y_pred，其他默认

```tsl
// 只给y_true和y_pred，其他默认
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
return recall_score(y_true, y_pred);
// array(1,0.0,0.0)
```

范例02：指定labels

```tsl
// 指定labels
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
labels := Array(2, 1, 0);
return recall_score(y_true, y_pred, nil, labels);
// array(0.0,0.0,1)
```

范例03：单标签二分类，指定pos_label，并且指定average为"binary"，

```tsl
// 单标签二分类，指定pos_label，并且指定average为"binary"，
// 只计算正例的precision
y_true := Array(0, 1, 1, 0, 1, 1);
y_pred := Array(0, 0, 1, 0, 0, 1);
pos_label := 0;
average := "binary";
return recall_score(y_true, y_pred, average, nil, pos_label); // 输出：1
```

范例04：指定average，指定计算precision的平均方式

```tsl
// 指定average，指定计算precision的平均方式
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
average := "macro"; // 宏平均，先计算各标签的precision再取平均
return recall_score(y_true, y_pred, average);
// 0.3333
```

范例05：指定sample_weight

```tsl
// 指定sample_weight
y_true := Array(0, 1, 2, 0, 1, 2);
y_pred := Array(0, 2, 1, 0, 0, 1);
sample_weight := array(1, 2, 3, 1, 1.5, 2);
return recall_score(y_true, y_pred, nil, nil, nil, sample_weight);
// array(1.0,0.0,0.0)
```

## `roc_curve(y_true, y_score, pos_label, sample_weight, drop_intermediate)`

声明：function

返回roc曲线序列值，适用于单标签二分类和多分类

<!-- tags: 金融 专题函数 机器学习 机器学习算法评价方法 分类算法评价指标 返回 获取 -->

| 参数                | 类型    | 说明                              |
| ------------------- | ------- | --------------------------------- |
| `y_true`            | array   | 真实标签                          |
| `y_score`           | array   | 预测输出概率                      |
| `pos_label`         | integer | 正例标签，默认是1，多分类必须提供 |
| `sample_weight`     | array   | 样本权重，默认等权重              |
| `drop_intermediate` | bool    | 是否去掉无用点，默认为真          |

返回：array

### 示例

范例01：只给y_true和y_pred，只有二分类时可以允许

```tsl
// 只给y_true和y_pred，只有二分类时可以允许
y_true := array(0, 1, 0, 0);
y_pred := array(0.1, 0.4, 0.35, 0.8);
return roc_curve(y_true, y_pred);
```

范例02：多分类是必须指定pos_label

```tsl
// 多分类是必须指定pos_label
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
return roc_curve(y_true, y_pred, pos_label);
```

范例03：指定sample_weight

```tsl
// 指定sample_weight
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
sample_weight := array(1, 2, 2.5, 1.3);
return roc_curve(y_true, y_pred, pos_label, sample_weight);
```

范例04：drop_intermediate为假时，不去掉无用点，使用_binary_clf_curve返回的原序列值

```tsl
// drop_intermediate为假时，不去掉无用点，使用_binary_clf_curve返回的原序列值
y_true := Array(1, 1, 2, 2);
y_pred := Array(0.1, 0.4, 0.35, 0.8);
pos_label := 2;
drop_intermediate := false;
return roc_curve(y_true, y_pred, pos_label, nil, drop_intermediate);
```
