Python手册(Machine Learning)--LightGBM

Overview

LightGBM（Light Gradient Boosting Machine）是一种高效的 Gradient Boosting 算法， 主要用于解决GBDT在海量数据中遇到的问题，以便更好更快的用于工业实践中。

lightgbm.Dataset(data, 
                 label=None, 
                 reference=None, 
                 weight=None, 
                 group=None, 
                 init_score=None, 
                 feature_name='auto', 
                 categorical_feature='auto', 
                 params=None, 
                 free_raw_data=True)
1
2
3
4
5
6
7
8
9
10

常用参数：

• data 内部数据集的数据源
• label 数据标签
• reference 在lightgbm中验证数据集应使用训练数据集作为参考。
• weight 每个样本的权重
• feature_name (list of str, or ‘auto’) 特征名称，默认 auto，如果数据是pandas.DataFrame，则使用数据列名称。
• categorical_feature (list of str, or ‘auto’) 分类特征名称。
• free_raw_data 如果为True，则在构建内部数据集后释放原始数据。如果想重复使用 Dataset ，则设为 False

import lightgbm as lgb
1

而在实际建模环节，LGBM支持Python、Java、C++等多种编程语言进行调用，并同时提供了Sklearn API和原生API两套调用方法。

从建模流程上来看，使用原生LGBM API时需要先对数据集进行封装，转化成一种LGBM库定义的一种特殊的数据格式，然后再设置超参数字典，最终带入封装好的数据集和定义好的超参数字典进行训练，而在训练的过程，则支持多种不同的损失函数设置、以及交叉验证的优化流程的自动实现，并且原生API还提供了非常多实用功能，例如提供了GPU加速、精细化控制每一轮迭代的超参数等方法。

Simple example：

Step 1: Load the dataset

# load or create your dataset
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# create train dataset for lightgbm
dtrain = lgb.Dataset(X_train, y_train)
# In LightGBM, the validation data should be aligned with training data.
deval = lgb.Dataset(X_test, y_test, reference=dtrain)

# if you want to re-use data, remember to set free_raw_data=False
dtrain = lgb.Dataset(X_train, y_train, free_raw_data=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

LightGBM 可以直接使用分类特征，而不需要 one-hot 编码，且比编码后的更快 (about 8x speed-up)

# Specific feature names and categorical features
dtrain = lgb.Dataset(X_train, y_train, categorical_feature='name:c1,c2,c3')
1
2

Note: 在构建 Dataset 前，先把分类特征转换成整数型

Step 2: Setting Parameters

# LightGBM can use a dictionary to set Parameters.

# Booster parameters:
params = {
    'boosting_type': 'gbdt',
    'objective': 'regression',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': 0
}
params['metric'] = 'l2'

# You can also specify multiple eval metrics:
params['metric'] = ['l2', 'l1']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Step 3: Training

# Training a model requires a parameter list and data set:
bst = lgb.train(params,
                dtrain,
                num_boost_round=20,
                valid_sets=deval,
                callbacks=[lgb.early_stopping(stopping_rounds=5)])

# Training with 5-fold CV:
lgb.cv(params, dtrain, num_boost_round=20, nfold=5)
1
2
3
4
5
6
7
8
9

Step 4: Save and load model

# Save model to file:
bst.save_model('model.txt')  
bst = lgb.Booster(model_file='model.txt')
# can only predict with the best iteration (or the saving iteration)

# Dump model to JSON:
import json
model_json = bst.dump_model()
with open('model.json', 'w+') as f:
    json.dump(model_json, f, indent=4)

# Dump model with pickle
import pickle
with open('model.pkl', 'wb') as fout:
    pickle.dump(gbm, fout)
with open('model.pkl', 'rb') as fin:
    pkl_bst = pickle.load(fin)
# can predict with any iteration when loaded in pickle way
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Step 5: Predict

# A model that has been trained or loaded can perform predictions on datasets:
y_pred = bst.predict(X_test)

# If early stopping is enabled during training, you can get predictions from the best iteration with bst.best_iteration:
y_pred = bst.predict(X_test, num_iteration=bst.best_iteration)
1
2
3
4
5

Step 6: Evaluating

from sklearn.metric import mean_squared_error
rmse_test = mean_squared_error(y_test, y_pred) ** 0.5
print(f'The RMSE of prediction is: {rmse_test}')
1
2
3

参数

lightgbm 的参数以 dict 的格式配置，然后训练的时候传递给 lightgbm.train 的 params 参数。接下来我们就逐个解释这些参数，并对其使用方法进行说明。

基本参数

task：指定任务类型。default = train，aliases：task_type

• train 用于训练，alias：training
• predict 用于预测，alias：prediction，test
• convert_model 将模型文件转换为if-else格式
• refit 用新数据刷新现有模型，alias：refit_tree
• save_binary 将数据集保存到二进制文件中

objective：指定目标函数。default = regression

• 回归问题：regression, regression_l1, huber, fair, poisson, quantile, mape, gamma, tweedie
• 分类问题：binary, multiclass, multiclassova 。对于多分类num_class参数也应该设置
• 交叉熵：cross_entropy, cross_entropy_lambda,
• 排序问题：lambdarank, rank_xendcg

boosting：指定算法类型。default = gbdt, aliases: boosting_type, boost

• gbdt：传统的梯度提升算法，是最常用、且性能最稳定的 boosting 类型。alias：gbrt。
• rf：传统的梯度促进决策树，alias：random_forest
• dart： (Dropouts meet Multiple Additive Regression Trees)是一种结合了 Dropout 和多重加性回归树的方法。它在每次迭代过程中随机选择一部分树进行更新，会较大程度增加模型随机性，可以用于存在较多噪声的数据集或者数据集相对简单（需要减少过拟合风险）的场景中

data_sample_strategy：default = bagging

• bagging：机装袋取样。注意，当 bagging_freq > 0 且 bagging_fraction < 1.0 时起作用。
• goss：（Gradient-based One-Side Sampling）是一种基于梯度的单侧采样方法。它在每次迭代中只使用具有较大梯度的样本进行训练，适用于大规模数据集，可以在保持较高精度的同时加速训练过程。

num_threads：并行的线程数。default = 0, aliases: num_thread, nthread, nthreads, n_jobs

device_type：学习设备。default = cpu, options: cpu, gpu, cuda, aliases: device

seed：随机种子。default = None, aliases: random_seed, random_state

verbosity：日志输出详细程度，default = 1 。aliases: verbose

• < 0 仅输出致命错误
• = 0显示警告和报错
• = 1 用于打印全部信息
• > 1 Debug

样本处理参数

特征处理参数

决策树生成

注意：feature_fraction 不受subsample_freq影响。同时需要注意的是，LGBM和随机森林不同，随机森林是每棵树的每次分裂时都随机分配特征，而LGBM是每次构建一颗树时随机分配一个特征子集，这颗树在成长过程中每次分裂都是依据这个特征子集进行生长。

训练过程控制

其中部分参数可在模型训练 lightgbm.train 时传递值：

注意：通过 params (dict) 传递的值优先于通过参数提供的值。

lightgbm.train(params, 
               train_set, 
               num_boost_round=100, 
               valid_sets=None, 
               valid_names=None, 
               feval=None, 
               init_model=None, 
               feature_name='auto', 
               categorical_feature='auto', 
               keep_training_booster=False, 
               callbacks=None)

lightgbm.cv(params, 
            train_set, 
            num_boost_round=100, 
            folds=None, nfold=5, 
            stratified=True, 
            shuffle=True, 
            metrics=None, 
            feval=None, 
            init_model=None, 
            feature_name='auto', 
            categorical_feature='auto', 
            fpreproc=None, 
            seed=0, 
            callbacks=None, 
            eval_train_metric=False, 
            return_cvbooster=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

回调参数

callbacks 参数标识在每次迭代中应用的回调函数列表。

自定义

lightgbm 在lgb.train中通过参数fobj和feval来自定损失函数和评估函数

advanced_example.py

注意：

1. 在LightGBM中，自定义损失函数需要返回损失函数的一阶(grad)和二阶(hess)导数。
2. 自定义损失函数后，模型的输出不在是 [0,1] 概率输出，而是 sigmoid 函数之前的输入值。
3. 自定义损失函数后，模型的输出已经发生改变，需要写出对应的评估函数。
4. 自定义损失函数后，LightGBM默认的boost_from_average=True失效，按照GBDT的框架，对于利用logloss来优化的二分类问题，样本的初始值为训练集标签的均值，在自定义损失函数后,系统无法获取到这个初始化值，导致收敛速度变慢。可以在构建lgb.Dataset时，利用init_score参数手动完成。
5. 自定义损失函数后，模型输出需要手动进行sigmoid函数变换

# NOTE: when you do customized loss function, the default prediction value is margin
# This may make built-in evaluation metric calculate wrong results
# For example, we are doing log likelihood loss, the prediction is score before logistic transformation
# Keep this in mind when you use the customization

# self-defined objective function
# f(preds: array, train_data: Dataset) -> grad: array, hess: array
# log likelihood loss
from scipy import special
def loglikelihood(preds, train_data):
    labels = train_data.get_label()
    preds = 1.0 / (1.0 + np.exp(-preds))
    grad = preds - labels
    hess = preds * (1.0 - preds)
    return grad, hess

# self-defined eval metric
# f(preds: array, train_data: Dataset) -> name: str, eval_result: float, is_higher_better: bool
def binary_error(preds, train_data):
    labels = train_data.get_label()
    preds = 1.0 / (1.0 + np.exp(-preds))
    return "error", np.mean(labels != (preds > 0.5)), False

# Pass custom objective function through params
params_custom_obj["objective"] = loglikelihood

gbm = lgb.train(
    params_custom_obj, lgb_train, num_boost_round=10, feval=binary_error, valid_sets=lgb_eval
)

y_pred = special.expit(gbm.predict(X_test))


# another self-defined eval metric
# f(preds: array, train_data: Dataset) -> name: str, eval_result: float, is_higher_better: bool
# accuracy

def accuracy(preds, train_data):
    labels = train_data.get_label()
    preds = 1.0 / (1.0 + np.exp(-preds))
    return "accuracy", np.mean(labels == (preds > 0.5)), True

# Pass custom objective function through params
params_custom_obj["objective"] = loglikelihood

gbm = lgb.train(
    params_custom_obj,
    lgb_train,
    num_boost_round=10,
    feval=[binary_error, accuracy],
    valid_sets=lgb_eval,
)

y_pred = special.expit(gbm.predict(X_test))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

lightgbm 可通过在callback中添加reset_parameter传递学习率，从而实现学习率衰减(learning rate decay)。

学习率接受两种参数类型：

1. num_boost_round 长度的 list
2. 以当前迭代次数为参数的函数 function(curr_iter)

# reset_parameter callback accepts:
# 1. list with length = num_boost_round
# 2. function(curr_iter)
bst = lgb.train(params,
                dtrain,
                num_boost_round=10,
                init_model=gbm,
                valid_sets=deval,
                callbacks=[lgb.reset_parameter(learning_rate=lambda iter: 0.05 * (0.99 ** iter))])

# change other parameters during training
bst = lgb.train(params,
                dtrain,
                num_boost_round=10,
                init_model=gbm,
                valid_sets=deval,
                callbacks=[lgb.reset_parameter(bagging_fraction=[0.7] * 5 + [0.6] * 5)])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Scikit-Learn API

LGBM的 sklearn API支持使用sklearn的调用风格和语言习惯进行LGBM模型训练，数据读取环节支持直接读取本地的Numpy或Pandas格式数据，而在实际训练过程中需要先实例化评估器并设置超参数，然后通过.fit的方式进行训练，并且可以直接调用grid search进行超参数搜索，也可以使用其他sklearn提供的高阶工具，如构建机器学习流、进行特征筛选或者进行模型融合等。

总的来看，LGBM的sklearn API更加轻量、便捷，并且能够无缝衔接sklearn中其他评估器，快速实现sklearn提供的高阶功能，对于熟悉sklearn的用户而言非常友好；而原生API则会复杂很多，但同时也提供了大量sklearn API无法实现的复杂功能，若能够合理使用，则可以实现相比sklearn API更精准的建模结果、更高效的建模流程。

其中LGBMModel是 LightGBM 的基本模型类，它是一个泛型模型类，可以用于各种类型的问题（如分类、回归等）。通常，我们不直接使用 LGBMModel，而是使用针对特定任务的子类使用不同的类，即分类问题使用 LGBMClassifier 、回归问题使用 LGBMRegressor，而排序问题则使用LGBMRanker。

以 LGBMClassifier 为例，默认参数如下：

LGBMClassifier(
    boosting_type: str = 'gbdt',
    num_leaves: int = 31,
    max_depth: int = -1,
    learning_rate: float = 0.1,
    n_estimators: int = 100,
    subsample_for_bin: int = 200000,
    objective: Union[str, Callable, NoneType] = None,
    class_weight: Union[Dict, str, NoneType] = None,
    min_split_gain: float = 0.0,
    min_child_weight: float = 0.001,
    min_child_samples: int = 20,
    subsample: float = 1.0,
    subsample_freq: int = 0,
    colsample_bytree: float = 1.0,
    reg_alpha: float = 0.0,
    reg_lambda: float = 0.0,
    random_state: Union[int, numpy.random.mtrand.RandomState, NoneType] = None,
    n_jobs: int = -1,
    silent: Union[bool, str] = 'warn',
    importance_type: str = 'split',
    **kwargs,
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

具体的模型训练过程和sklearn中其他模型一样，通过fit进行训练，并利用predict进行结果输出：

import lightgbm as lgb
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

# Step 1: load or create your dataset
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Step 2: Training
gbm = lgb.LGBMRegressor(num_leaves=31,
                        learning_rate=0.05,
                        n_estimators=20)
gbm.fit(X_train, y_train,
        eval_set=[(X_test, y_test)],
        eval_metric='l1',
        callbacks=[lgb.early_stopping(5)])


# Step 5:  Predict
y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration_)
y_score = gbm.predict_proba(X_test num_iteration=gbm.best_iteration_)

# Step 6:  Evaluate
rmse_test = mean_squared_error(y_test, y_pred) ** 0.5
print(f'The RMSE of prediction is: {rmse_test}')

# feature importances
print(f'Feature importances: {list(gbm.feature_importances_)}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

可以与sklearn中其他方法无缝衔接：

# other scikit-learn modules
from sklearn.model_selection import GridSearchCV

param_grid = {
    'learning_rate': [0.01, 0.1, 1],
    'n_estimators': [20, 40]
}

gbm = GridSearchCV(estimator, param_grid, cv=3)
gbm.fit(X_train, y_train)

print(f'Best parameters found by grid search are: {gbm.best_params_}')
1
2
3
4
5
6
7
8
9
10
11
12

可视化

evals_result = {}  # to record eval results for plotting
gbm = lgb.train(
    params,
    dtrain,
    num_boost_round=100,
    valid_sets=[dtrain, deval],
    callbacks=[
        lgb.log_evaluation(10),
        lgb.record_evaluation(evals_result)
    ]
)

# Plotting metrics recorded during training
ax = lgb.plot_metric(evals_result, metric='l1')
plt.show()

# Plotting feature importances
ax = lgb.plot_importance(gbm, max_num_features=10)
plt.show()

# Plotting split value histogram
ax = lgb.plot_split_value_histogram(gbm, feature='f26', bins='auto')
plt.show()

# Plotting 54th tree (one tree use categorical feature to split)
ax = lgb.plot_tree(gbm, tree_index=53, figsize=(15, 15), show_info=['split_gain'])
plt.show()

# Plotting 54th tree with graphviz
graph = lgb.create_tree_digraph(gbm, tree_index=53, name='Tree54')
graph.render(view=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

继续训练

lightGBM有两种增量学习方式：

1. init_model参数：如果 init_model不为None，将从这个模型基础上继续训练，添加 num_boost_round 棵新树

# init_model accepts:
# 1. model file name
# 2. Booster()
bst = lgb.train(previous_params,
                new_data,
                num_boost_round=10,
                init_model=previous_model, 
                valid_sets=eval_data,
                keep_training_booster=True
               )
1
2
3
4
5
6
7
8
9
10

其中 keep_training_booster (bool) 参数表示返回的模型 (booster) 是否将用于保持训练，默认False。当模型非常大并导致内存错误时，可以尝试将此参数设置为True，以避免 model_to_string 转换。然后仍然可以使用返回的booster作为init_model，用于未来的继续训练。

2. 调用 refit 方法：在原有模型的树结构都不变的基础上，重新拟合新数据更新叶子节点权重

# 在参数字典中配置
params = {
	'task':'refit', 
	'refit_decay_rate': 0.9,
	'boosting_type':'gbdt',
	'objective':'binary',
	'metric':'auc'
	}

bst = lgb.train(
		params,
		dtrain,
		num_boost_round=20, 
		valid_sets=[dtrain, deval]
	)

# 用返回的模型 (Booster) 重新拟合
bst.refit(
    data=X_train,
    label=y_train,
    decay_rate=0.9,
    reference=None
  )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

其中 refit_decay_rate 控制 refit 任务中学习率的衰减。重新拟合后，叶子结点的输出的计算公式为

leaf_output = refit_decay_rate * old_leaf_output + (1.0 - refit_decay_rate) * new_leaf_output
1

分布式学习

LGBM还提供了分布式计算版本和GPU计算版本进行加速计算，其中分布式计算模式下支持从HDFS（Hadoop Distributed File System）系统中进行数据读取和计算，而GPU计算模式下则提供了GPU version（借助OpenCL，即Open Computing Language来实现多种不同GPU的加速计算）和CUDA version（借助CUDA，即Compute Unified Device Architecture来实现NVIDIA GPU加速）。不过，不同于深度学习更倾向于使用CUDA加速，对于LGBM而言，由于目前CUDA version只能在Linux操作系统下实现，因此大多数情况下，我们往往会选择支持Windows系统的GPU version进行GPU加速计算。

LightGBM 目前提供3种分布式学习算法：

这些算法适用于不同的场景：

tree_learner 参数控制分布式学习方法。default = serial, aliases: tree, tree_type, tree_learner_type

• serial：单机学习
• feature：特征并行，别名：feature_parallel
• data：数据并行，别名：data_parallel
• voting：投票平行，别名：voting_parallel

LightGBM with PySpark

要在spark上使用LightGBM，需要安装SynapseML包，原名MMLSpark，由微软开发维护。SynapseML建立在Apache Spark分布式计算框架上，与SparkML/MLLib库共享相同的API，允许您将SynapseML模型无缝嵌入到现有的Apache Spark工作流程中。

SynapseML在Python中安装：首先，默认已经安装好了PySpark，然后，通过pyspark.sql.SparkSession配置会自动下载并安装到现有的Spark集群上

import pyspark
# Use 0.11.4-spark3.3 version for Spark3.3 and 1.0.2 version for Spark3.4
spark = pyspark.sql.SparkSession.builder.appName("MyApp") \
            .config("spark.jars.packages", "com.microsoft.azure:synapseml_2.12:1.0.2") \
            .config("spark.jars.repositories", "https://mmlspark.azureedge.net/maven") \
            .getOrCreate()
import synapse.ml
1
2
3
4
5
6
7

或者通过启动Spark时配置--packages选项

# Use 0.11.4-spark3.3 version for Spark3.3 and 1.0.2 version for Spark3.4
spark-shell --packages com.microsoft.azure:synapseml_2.12:1.0.2
pyspark --packages com.microsoft.azure:synapseml_2.12:1.0.2
spark-submit --packages com.microsoft.azure:synapseml_2.12:1.0.2 MyApp.jar
1
2
3
4

这个包比较大，第一次安装需要较长时间。

在PySpark中，您可以通过以下方式运行LightGBMClassifier：

from synapse.ml.lightgbm import LightGBMClassifier
model = LightGBMClassifier(learningRate=0.3,
                           numIterations=100,
                           numLeaves=31).fit(train)
1
2
3
4

LightGBM的参数比SynapseML公开的要多得多，若要添加额外的参数，请使用passThroughArgs字符串参数配置。

from synapse.ml.lightgbm import LightGBMClassifier
model = LightGBMClassifier(passThroughArgs="force_row_wise=true min_sum_hessian_in_leaf=2e-3",
                           numIterations=100,
                           numLeaves=31).fit(train)
1
2
3
4

您可以混合passThroughArgs和显式args，如示例所示。SynapseML合并它们以创建一个要发送到LightGBM的参数字符串。如果您在两个地方都设置参数，则以passThroughArgs为优先。

示例：

# Read dataset
from synapse.ml.core.platform import *
df = (
    spark.read.format("csv")
    .option("header", True)
    .option("inferSchema", True)
    .load(
        "wasbs://publicwasb@mmlspark.blob.core.windows.net/company_bankruptcy_prediction_data.csv"
    )
)
# print dataset size
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()
display(df)

# Split the dataset into train and test
train, test = df.randomSplit([0.85, 0.15], seed=1)

# Add featurizer to convert features to vector
from pyspark.ml.feature import VectorAssembler

feature_cols = df.columns[1:]
featurizer = VectorAssembler(inputCols=feature_cols, outputCol="features")
train_data = featurizer.transform(train)["Bankrupt?", "features"]
test_data = featurizer.transform(test)["Bankrupt?", "features"]

# Check if the data is unbalanced
display(train_data.groupBy("Bankrupt?").count())

# Model Training
from synapse.ml.lightgbm import LightGBMClassifier

model = LightGBMClassifier(
    objective="binary", featuresCol="features", labelCol="Bankrupt?", isUnbalance=True
)
model = model.fit(train_data)

# "saveNativeModel" allows you to extract the underlying lightGBM model for fast deployment after you train on Spark.
from synapse.ml.lightgbm import LightGBMClassificationModel

if running_on_synapse():
    model.saveNativeModel("/models/lgbmclassifier.model")
    model = LightGBMClassificationModel.loadNativeModelFromFile(
        "/models/lgbmclassifier.model"
    )
if running_on_synapse_internal():
    model.saveNativeModel("Files/models/lgbmclassifier.model")
    model = LightGBMClassificationModel.loadNativeModelFromFile(
        "Files/models/lgbmclassifier.model"
    )
else:
    model.saveNativeModel("/tmp/lgbmclassifier.model")
    model = LightGBMClassificationModel.loadNativeModelFromFile(
        "/tmp/lgbmclassifier.model"
    )

# Feature Importances Visualization
import pandas as pd
import matplotlib.pyplot as plt

feature_importances = model.getFeatureImportances()
fi = pd.Series(feature_importances, index=feature_cols)
fi = fi.sort_values(ascending=True)
f_index = fi.index
f_values = fi.values

# print feature importances
print("f_index:", f_index)
print("f_values:", f_values)

# plot
x_index = list(range(len(fi)))
x_index = [x / len(fi) for x in x_index]
plt.rcParams["figure.figsize"] = (20, 20)
plt.barh(
    x_index, f_values, height=0.028, align="center", color="tan", tick_label=f_index
)
plt.xlabel("importances")
plt.ylabel("features")
plt.show()

# Model Prediction
predictions = model.transform(test_data)
predictions.limit(10).toPandas()

from synapse.ml.train import ComputeModelStatistics

metrics = ComputeModelStatistics(
    evaluationMetric="classification",
    labelCol="Bankrupt?",
    scoredLabelsCol="prediction",
).transform(predictions)
display(metrics)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94