Partilhar via

Usar modelos LightGBM com SynapseML no Microsoft Fabric

  • Artigo

A estrutura LightGBM é especializada na criação de algoritmos de árvore de decisão de alta qualidade e habilitados para GPU para classificação, classificação e muitas outras tarefas de aprendizado de máquina. Neste artigo, você usa o LightGBM para criar modelos de classificação, regressão e classificação.

O LightGBM é uma estrutura de aumento de gradiente (GBDT, GBRT, GBM ou MART) de código aberto, distribuída e de alto desempenho. LightGBM faz parte do projeto DMTK da Microsoft. Você pode usar LightGBM usando LightGBMClassifier, LightGBMRegressor e LightGBMRanker. O LightGBM vem com as vantagens de ser incorporado em pipelines SparkML existentes e usado para cargas de trabalho em lote, streaming e serviço. Ele também oferece uma ampla gama de parâmetros ajustáveis, que se pode usar para personalizar seu sistema de árvore de decisão. O LightGBM no Spark também suporta novos tipos de problemas, como regressão quantílica.

Pré-requisitos

  • Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para uma avaliação gratuita do Microsoft Fabric.

  • Entre no Microsoft Fabric.

  • Use o seletor de experiência no lado esquerdo da sua página inicial para alternar para a experiência Synapse Data Science.

    Captura de tela do menu do seletor de experiência, mostrando onde selecionar Ciência de Dados.

  • Vá para a experiência de Ciência de Dados no Microsoft Fabric.
  • Crie um novo bloco de notas.
  • Ligue o seu bloco de notas a uma casa no lago. No lado esquerdo do seu bloco de notas, selecione Adicionar para adicionar uma lakehouse existente ou criar uma nova.

Uso LightGBMClassifier para treinar um modelo de classificação

Nesta seção, você usa o LightGBM para criar um modelo de classificação para prever falências.

  1. Leia o conjunto de dados.

    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. Divida o conjunto de dados em conjuntos de trem e teste.

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

  3. Adicione um featurizer para converter recursos em vetores.

    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. Verifique se os dados estão desequilibrados.

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

  5. Treine o modelo usando LightGBMClassifiero .

    from synapse.ml.lightgbm import LightGBMClassifier

model = LightGBMClassifier(
    objective="binary", featuresCol="features", labelCol="Bankrupt?", isUnbalance=True, dataTransferMode="bulk"
)

    model = model.fit(train_data)

  6. Visualize a importância do recurso

    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. Gere previsões com o modelo

    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)

Use LightGBMRegressor para treinar um modelo de regressão quantílica

Nesta seção, você usa o LightGBM para criar um modelo de regressão para a descoberta de medicamentos.

  1. Leia o conjunto de dados.

    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. Divida o conjunto de dados em conjuntos de trem e teste.

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

  3. Treine o modelo usando LightGBMRegressoro .

    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. Gere previsões com o modelo.

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

    from synapse.ml.train import ComputeModelStatistics

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

Use LightGBMRanker para treinar um modelo de classificação

Nesta seção, você usa o LightGBM para criar um modelo de classificação.

  1. Leia o conjunto de dados.

    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. Treine o modelo de classificação usando LightGBMRankero .

    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. Gere previsões com o modelo.

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

Conteúdos relacionados