Condividi tramite

Usare modelli LightGBM con SynapseML in Microsoft Fabric

  • Articolo

Il framework LightGBM è specializzato nella creazione di algoritmi di albero delle decisioni abilitati per GPU e di alta qualità per la valutazione, la classificazione e molte altre attività di apprendimento automatico. In questo articolo si usa LightGBM per compilare modelli di classificazione, regressione e classificazione.

LightGBM è un framework open source, distribuito e a prestazioni elevate di gradient boosting (GBDT, GBRT, GBM, o MART). LightGBM fa parte del progetto DMTK di Microsoft. È possibile usare LightGBM usando LightGBMClassifier, LightGBMRegressor e LightGBMRanker. LightGBM offre i vantaggi dell'incorporazione nelle pipeline SparkML esistenti e usata per batch, streaming e gestione dei carichi di lavoro. Offre anche un'ampia gamma di parametri ottimizzabili, che è possibile usare per personalizzare il sistema di albero delle decisioni. LightGBM in Spark supporta anche nuovi tipi di problemi, ad esempio la regressione quantile.

Prerequisiti

  • Passare all'esperienza di data science in Microsoft Fabric.
  • Creare un nuovo notebook.
  • Collegare il notebook a un lakehouse. Sul lato sinistro del notebook, selezionare Aggiungi per aggiungere un lakehouse esistente o crearne uno nuovo.

Usare LightGBMClassifier per eseguire il training di un modello di classificazione

In questa sezione si usa LightGBM per creare un modello di classificazione per la stima del fallimento.

  1. Leggere il set di dati.

    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. Dividere il set di dati in set di training e di test.

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

  3. Aggiungere un predefinito per convertire le funzionalità in vettori.

    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. Controllare se i dati sono sbilanciati.

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

  5. Eseguire il training del modello usando 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. Visualizzare l'importanza della funzionalità

    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. Generare stime con il modello

    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)

Usare LightGBMRegressor per eseguire il training di un modello di regressione quantile

In questa sezione si usa LightGBM per creare un modello di regressione per l'individuazione dei farmaci.

  1. Leggere il set di dati.

    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. Dividere il set di dati in set di training e di test.

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

  3. Eseguire il training del modello usando 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. Generare stime con il modello.

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

    from synapse.ml.train import ComputeModelStatistics

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

Usare LightGBMRanker per eseguire il training di un modello di classificazione

In questa sezione si usa LightGBM per creare un modello di classificazione.

  1. Leggere il set di dati.

    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. Eseguire il training del modello di classificazione usando 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. Generare stime con il modello.

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

Contenuto correlato