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.
- 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.
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)
Del datasettet inn i tog- og testsett.
train, test = df.randomSplit([0.85, 0.15], seed=1)
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"]
Kontroller om dataene er ubalanserte.
display(train_data.groupBy("Bankrupt?").count())
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)
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()
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.
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))
Del datasettet inn i tog- og testsett.
train, test = triazines.randomSplit([0.85, 0.15], seed=1)
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())
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.
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))
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)
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()