Compartir vía

Uso de modelos LightGBM con SynapseML en Microsoft Fabric

  • Artículo

El framework LightGBM está especializado en la creación de algoritmos de árboles de decisión de alta calidad y compatibles con la GPU para clasificación, ordenación y muchas otras tareas de aprendizaje automático. En este artículo, usará LightGBM para compilar modelos de clasificación, regresión y clasificación.

LightGBM es un framework de potenciación de gradiente (GBDT, GBRT, GBM o MART) de código abierto, distribuido y de alto rendimiento. LightGBM forma parte del proyecto DMTK de Microsoft. Puede usar LightGBM mediante LightGBMClassifier, LightGBMRegressor y LightGBMRanker. LightGBM tiene la ventaja que está incorporado en canalizaciones de SparkML existentes y se usa para cargas de trabajo por lotes, de streaming y de servicio. También ofrece una amplia gama de parámetros sintonizables, que uno puede utilizar para personalizar su sistema de árbol de decisión. LightGBM en Spark también admite nuevos tipos de problemas, como la regresión cuantil.

Requisitos previos

  • Vaya a la experiencia de Ciencia de datos en Microsoft Fabric.
  • Creación de un cuaderno.
  • Adjunte el cuaderno a un almacén de lago. En la parte izquierda de su cuaderno, seleccione Añadir para añadir una casa lacustre existente o crear una nueva.

Utilizar LightGBMClassifier para entrenar un modelo de clasificación

En esta sección, usará LightGBM para compilar un modelo de clasificación para predecir la quiebra.

  1. Lea el conjunto de datos.

    from pyspark.sql import SparkSession

# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()

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)

  2. Divide el conjunto de datos en conjuntos de entrenamiento y prueba.

    train, test = df.randomSplit([0.85, 0.15], seed=1)

  3. Agregue un caracterizador para convertir características en vectores.

    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"]

  4. Compruebe si los datos están desequilibrados.

    display(train_data.groupBy("Bankrupt?").count())

  5. Entrena el modelo con LightGBMClassifier.

    from synapse.ml.lightgbm import LightGBMClassifier

model = LightGBMClassifier(
    objective="binary", featuresCol="features", labelCol="Bankrupt?", isUnbalance=True, dataTransferMode="bulk"
)

    model = model.fit(train_data)

  6. Visualización de la importancia de las características

    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()

  7. Generar predicciones con el modelo

    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)

Utilizar LightGBMRegressor para entrenar un modelo de regresión cuantil

En esta sección, usará LightGBM para compilar un modelo de regresión para la detección de drogas.

  1. Lea el conjunto de datos.

    triazines = spark.read.format("libsvm").load(
    "wasbs://publicwasb@mmlspark.blob.core.windows.net/triazines.scale.svmlight"
)

    # print some basic info
print("records read: " + str(triazines.count()))
print("Schema: ")
triazines.printSchema()
display(triazines.limit(10))

  2. Divide el conjunto de datos en conjuntos de entrenamiento y prueba.

    train, test = triazines.randomSplit([0.85, 0.15], seed=1)

  3. Entrena el modelo con LightGBMRegressor.

    from synapse.ml.lightgbm import LightGBMRegressor

model = LightGBMRegressor(
    objective="quantile", alpha=0.2, learningRate=0.3, numLeaves=31, dataTransferMode="bulk"
).fit(train)

    print(model.getFeatureImportances())

  4. Genere predicciones con el modelo.

    scoredData = model.transform(test)
display(scoredData)

    from synapse.ml.train import ComputeModelStatistics

metrics = ComputeModelStatistics(
    evaluationMetric="regression", labelCol="label", scoresCol="prediction"
).transform(scoredData)
display(metrics)

Uso LightGBMRanker para entrenar un modelo de clasificación

En esta sección, usará LightGBM para compilar un modelo de clasificación.

  1. Lea el conjunto de datos.

    df = spark.read.format("parquet").load(
    "wasbs://publicwasb@mmlspark.blob.core.windows.net/lightGBMRanker_train.parquet"
)
# print some basic info
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()
display(df.limit(10))

  2. Entrene el modelo de clasificación mediante LightGBMRanker.

    from synapse.ml.lightgbm import LightGBMRanker

features_col = "features"
query_col = "query"
label_col = "labels"
lgbm_ranker = LightGBMRanker(
    labelCol=label_col,
    featuresCol=features_col,
    groupCol=query_col,
    predictionCol="preds",
    leafPredictionCol="leafPreds",
    featuresShapCol="importances",
    repartitionByGroupingColumn=True,
    numLeaves=32,
    numIterations=200,
    evalAt=[1, 3, 5],
    metric="ndcg",
    dataTransferMode="bulk"
)

    lgbm_ranker_model = lgbm_ranker.fit(df)

  3. Genere predicciones con el modelo.

    dt = spark.read.format("parquet").load(
    "wasbs://publicwasb@mmlspark.blob.core.windows.net/lightGBMRanker_test.parquet"
)
predictions = lgbm_ranker_model.transform(dt)
predictions.limit(10).toPandas()

Contenido relacionado