Dela via

Använda LightGBM-modeller med SynapseML i Microsoft Fabric

  • Artikel

LightGBM-ramverket är specialiserat på att skapa beslutsträdsalgoritmer av hög kvalitet och GPU-aktiverade för rangordning, klassificering och många andra maskininlärningsuppgifter. I den här artikeln använder du LightGBM för att skapa klassificerings-, regressions- och rangordningsmodeller.

LightGBM är ett ramverk med öppen källkod, distribuerad toning med höga prestanda (GBDT, GBRT, GBM eller MART). LightGBM är en del av Microsofts DMTK-projekt . Du kan använda LightGBM med hjälp av LightGBMClassifier, LightGBMRegressor och LightGBMRanker. LightGBM har fördelarna med att införlivas i befintliga SparkML-pipelines och användas för batch-, strömnings- och serveringsarbetsbelastningar. Det erbjuder också ett brett utbud av justerbara parametrar, som man kan använda för att anpassa sitt beslutsträdssystem. LightGBM på Spark stöder också nya typer av problem, till exempel kvantilregression.

Förutsättningar

  • Gå till den Datavetenskap upplevelsen i Microsoft Fabric.
  • Skapa en ny notebook-fil.
  • Bifoga anteckningsboken till ett sjöhus. Till vänster i anteckningsboken väljer du Lägg till för att lägga till ett befintligt lakehouse eller skapa ett nytt.

Använda LightGBMClassifier för att träna en klassificeringsmodell

I det här avsnittet använder du LightGBM för att skapa en klassificeringsmodell för att förutsäga konkurs.

  1. Läs datauppsättningen.

    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. Dela upp datamängden i tränings- och testuppsättningar.

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

  3. Lägg till en featurizer för att konvertera funktioner till vektorer.

    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. Kontrollera om data är obalanserade.

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

  5. Träna modellen med .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. Visualisera funktionsvikt

    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. Generera förutsägelser med modellen

    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)

Använd LightGBMRegressor för att träna en kvantilregressionsmodell

I det här avsnittet använder du LightGBM för att skapa en regressionsmodell för läkemedelsidentifiering.

  1. Läs datauppsättningen.

    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. Dela upp datamängden i tränings- och testuppsättningar.

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

  3. Träna modellen med .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. Generera förutsägelser med modellen.

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

    from synapse.ml.train import ComputeModelStatistics

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

Använda LightGBMRanker för att träna en rangordningsmodell

I det här avsnittet använder du LightGBM för att skapa en rangordningsmodell.

  1. Läs datauppsättningen.

    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. Träna rangordningsmodellen med .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. Generera förutsägelser med modellen.

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

Relaterat innehåll