Partager via

Utiliser des modèles LightGBM avec SynapseML dans Microsoft Fabric

  • Article

Le framework LightGBM est spécialisé dans la création d'algorithmes d'arbre de décision de haute qualité et compatibles GPU pour le classement, la classification et de nombreuses autres tâches d'apprentissage automatique. Dans cet article, vous utilisez LightGBM pour créer des modèles de classification, de régression et de classement.

LightGBM est un framework open-source, distribué et hautes performances d'amplification de gradient (GBDT, GBRT, GBM ou MART). LightGBM fait partie du projet DMTK de Microsoft. Vous pouvez utiliser LightGBM à l'aide de LightGBMClassifier, LightGBMRegressor et LightGBMRanker. LightGBM est avantageux dans la mesure où il peut être incorporé dans les pipelines SparkML existants et utilisé pour les charges de travail par lot, de diffusion en continu et de service. Il offre un large éventail de paramètres réglables, que l'on peut utiliser pour personnaliser son système d'arbre de décision. LightGBM sur Spark prend également en charge de nouveaux types de problèmes tels que la régression quantile.

Prérequis

  • Accédez à l'expérience Data Science dans Microsoft Fabric.
  • Créez un nouveau bloc-notes.
  • Attachez votre notebook à lakehouse. Sur le côté gauche de votre bloc-notes, sélectionnez Ajouter pour ajouter une maison de lac existante ou en créer une nouvelle.

Utiliser LightGBMClassifier pour entraîner un modèle de classification

Dans cette section, vous utilisez LightGBM pour créer un modèle de classification pour prédire la faillite.

  1. Lisez le jeu de données.

    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. Divisez l'ensemble de données en ensembles d'apprentissage et de test.

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

  3. Ajoutez un featurer pour convertir les entités en vecteurs.

    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. Vérifiez si les données sont déséquilibrées.

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

  5. Entraînez le modèle à l'aide de 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. Visualisez l'importance des fonctionnalités

    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. Générer des prédictions avec le modèle

    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)

Utiliser LightGBMRegressor pour former un modèle de régression quantile

Dans cette section, vous utilisez LightGBM pour créer un modèle de régression pour la découverte de médicaments.

  1. Lisez le jeu de données.

    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. Divisez l'ensemble de données en ensembles d'apprentissage et de test.

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

  3. Entraînez le modèle à l'aide de 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. Générez des prédictions avec le modèle.

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

    from synapse.ml.train import ComputeModelStatistics

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

Utiliser LightGBMRanker pour former un modèle de classement

Dans cette section, vous utilisez LightGBM pour créer un modèle de classement.

  1. Lisez le jeu de données.

    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. Entraînez le modèle de classement à l'aide de 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. Générez des prédictions avec le modèle.

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

Contenu connexe