Partager via


Utiliser des modèles LightGBM avec SynapseML dans Microsoft Fabric

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