Del via


Bruke LightGBM-modeller med SynapseML i Microsoft Fabric

LightGBM-rammeverket spesialiserer seg på å opprette høykvalitets- og GPU-aktiverte beslutningstrealgoritmer for rangering, klassifisering og mange andre maskinlæringsoppgaver. I denne artikkelen bruker du LightGBM til å bygge klassifiserings-, regresjons- og rangeringsmodeller.

LightGBM er et rammeverk med åpen kildekode, distribuert gradering med høy ytelse (GBDT, GBRT, GBM eller MART). LightGBM er en del av Microsofts DMTK-prosjekt . Du kan bruke LightGBM ved hjelp av LightGBMClassifier, LightGBMRegressor og LightGBMRanker. LightGBM kommer med fordelene ved å bli innlemmet i eksisterende SparkML-rørledninger og brukes til batch, streaming og servering av arbeidsbelastninger. Det tilbyr også et bredt utvalg av tunable parametere, som man kan bruke til å tilpasse beslutningstresystemet. LightGBM på Spark støtter også nye typer problemer, for eksempel quantile regresjon.

Forutsetning

  • Få et Microsoft Fabric-abonnement. Eller registrer deg for en gratis prøveversjon av Microsoft Fabric.

  • Logg på Microsoft Fabric.

  • Bruk opplevelsesbryteren nederst til venstre på hjemmesiden for å bytte til Fabric.

    Skjermbilde av menyen for opplevelsesbryteren, som viser hvor du velger Datavitenskap.

  • Gå til Data Science-opplevelsen i Microsoft Fabric.
  • Opprett en ny notatblokk.
  • Legg notatblokken til et lakehouse. På venstre side av notatblokken velger du Legg til for å legge til et eksisterende lakehouse eller opprette et nytt.

Bruk LightGBMClassifier denne til å lære opp en klassifiseringsmodell

I denne delen bruker du LightGBM til å bygge en klassifiseringsmodell for å forutsi konkurs.

  1. Les datasettet.

    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. Del datasettet inn i tog- og testsett.

    train, test = df.randomSplit([0.85, 0.15], seed=1)
    
  3. Legg til en featurizer for å konvertere funksjoner til 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. Kontroller om dataene er ubalanserte.

    display(train_data.groupBy("Bankrupt?").count())
    
  5. Kalibrer modellen ved hjelp av 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. Visualiser viktighet for funksjoner

    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. Generer prognoser 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)
    

Bruk LightGBMRegressor denne til å lære opp en quantile regresjonsmodell

I denne delen bruker du LightGBM til å bygge en regresjonsmodell for narkotikaoppdagelse.

  1. Les datasettet.

    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. Del datasettet inn i tog- og testsett.

    train, test = triazines.randomSplit([0.85, 0.15], seed=1)
    
  3. Kalibrer modellen ved hjelp av 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. Generer prognoser 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)
    

Bruk LightGBMRanker denne til å lære opp en rangeringsmodell

I denne delen bruker du LightGBM til å bygge en rangeringsmodell.

  1. Les datasettet.

    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. Kalibrer rangeringsmodellen ved hjelp av 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. Generer prognoser 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()