Freigeben über

Verwenden von LightGBM-Modellen mit SynapseML in Microsoft Fabric

  • Artikel

Das LightGBM-Framework ist auf die Erstellung qualitativ hochwertiger und GPU-fähiger Entscheidungsstrukturalgorithmen zur Bewertung, Klassifizierung und viele andere Aufgaben in Bezug auf maschinelles Lernen spezialisiert. In diesem Artikel verwenden Sie LightGBM, um Klassifizierungs-, Regressions- und Bewertungsmodelle zu erstellen.

LightGBM ist ein verteiltes Open-Source-Framework mit hochleistungsfähigem Gradient Boosting (GBDT, GBRT, GBM oder MART). LightGBM ist Teil des DMTK-Projekts von Microsoft. Sie können LightGBM mit LightGBMClassifier, LightGBMRegressor und LightGBMRanker verwenden. Kombinierbarkeit: LightGBM-Modelle können mit vorhandenen SparkML-Pipelines integriert und für Batch-, Streaming- und Bereitstellungsworkloads verwendet werden. Funktionalität: LightGBM bietet eine breite Palette von anpassbaren Parametern, die zum Einstellen des Entscheidungsstruktursystems verwendet werden können. LightGBM in Spark hilft auch bei neuen Arten von Problemen wie der Quantilregression.

Voraussetzungen

  • Navigieren Sie zur Data Science-Benutzeroberfläche in Microsoft Fabric.
  • Erstellen Sie ein neues Notebook.
  • Verbinden Sie Ihr Notebook mit einem Lakehouse. Wählen Sie auf der linken Seite Ihres Notebooks Hinzufügen aus, um ein vorhandenes Lakehouse hinzuzufügen oder ein neues zu erstellen.

Verwenden von LightGBMClassifier zum Trainieren eines Klassifizierungsmodells

In diesem Abschnitt verwenden Sie LightGBM, um ein Klassifizierungsmodell für die Konkursvorhersage zu erstellen.

  1. Lesen Sie das Dataset.

    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. Teilen Sie das Dataset in Trainings- und Testdatasets auf.

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

  3. Fügen Sie einen Featurizer hinzu, um Features in Vektoren zu konvertieren.

    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. Überprüfen Sie, ob die Daten unausgeglichen sind.

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

  5. Trainieren Sie das Modell mithilfe von 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. Visualisieren Sie die Featurerelevanz

    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. Generieren Sie Vorhersagen mit dem Modell

    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)

Verwenden von LightGBMRegressor zum Trainieren eines Quantilregressionsmodells

In diesem Abschnitt verwenden Sie LightGBM, um ein Regressionsmodell für die Wirkstoffermittlung zu erstellen.

  1. Lesen Sie das Dataset.

    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. Teilen Sie das Dataset in Trainings- und Testdatasets auf.

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

  3. Trainieren Sie das Modell mithilfe von 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. Generieren Sie Vorhersagen mit dem Modell.

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

    from synapse.ml.train import ComputeModelStatistics

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

Verwenden Sie LightGBMRanker zum Trainieren eines Bewertungsmodells

In diesem Abschnitt verwenden Sie LightGBM, um ein Bewertungsmodell zu erstellen.

  1. Lesen Sie das Dataset.

    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. Trainieren Sie das Bewertungsmodell mithilfe von 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. Generieren Sie Vorhersagen mit dem Modell.

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

Zugehöriger Inhalt