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 classificazione, la classificazione e molte altre attività di Machine Learning. In questo articolo si userà LightGBM per compilare modelli di classificazione, regressione e classificazione.

LightGBM è un framework open source, distribuito e ad alte prestazioni con boosting delle sfumature (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

  • Ottenere una sottoscrizione di Microsoft Fabric. In alternativa, iscriversi per ottenere una versione di valutazione gratuita di Microsoft Fabric.

  • Accedere a Microsoft Fabric.

  • Usare il commutatore esperienza sul lato sinistro della home page per passare all'esperienza di data science di Synapse.

    Screenshot of the experience switcher menu, showing where to select Data Science.

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

Usare LightGBMClassifier per eseguire il training di un modello di classificazione

In questa sezione si userà 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. Suddividere il set di dati in set di training e 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 userà 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. Suddividere il set di dati in set di training e 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 userà 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