Tutorial: Criar, avaliar e pontuar um modelo de deteção de fraude

Este tutorial apresenta um exemplo completo de um fluxo de trabalho Synapse Data Science, no Microsoft Fabric. O cenário constrói um modelo de deteção de fraudes com algoritmos de aprendizado de máquina treinados em dados históricos. Em seguida, usa o modelo para detetar futuras transações fraudulentas.

Este tutorial aborda estas etapas:

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.

  

• Se necessário, crie uma casa de lago do Microsoft Fabric conforme descrito em Criar uma casa de lago no Microsoft Fabric.

Acompanhe num caderno

Você pode escolher uma destas opções para acompanhar em um bloco de anotações:

• Abra e execute o bloco de anotações integrado na experiência de Ciência de Dados
• Carregue seu bloco de anotações do GitHub para a experiência de Ciência de Dados

Abra o bloco de notas incorporado

O bloco de anotações de deteção de fraude de exemplo acompanha este tutorial.

Para abrir o bloco de anotações de exemplo integrado do tutorial na experiência Synapse Data Science:

1. Vá para a página inicial do Synapse Data Science.

2. Selecione Usar uma amostra.

3. Selecione a amostra correspondente:

   • Na guia padrão End-to-end workflows (Python), se o exemplo for para um tutorial do Python.
   • Na guia Fluxos de trabalho de ponta a ponta (R), se o exemplo for para um tutorial R.
   • Na guia Tutoriais rápidos, se o exemplo for para um tutorial rápido.

4. Anexe um lakehouse ao bloco de anotações antes de começar a executar o código.

Importar o bloco de anotações do GitHub

O notebook AIsample - Fraud Detection.ipynb acompanha este tutorial.

Para abrir o bloco de anotações que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados, para importar o bloco de anotações para seu espaço de trabalho.

Se preferir copiar e colar o código desta página, pode criar um novo bloco de notas.

Certifique-se de anexar um lakehouse ao bloco de anotações antes de começar a executar o código.

Etapa 1: Instalar bibliotecas personalizadas

Para desenvolvimento de modelo de aprendizado de máquina ou análise de dados ad-hoc, talvez seja necessário instalar rapidamente uma biblioteca personalizada para sua sessão do Apache Spark. Você tem duas opções para instalar bibliotecas.

• Utilize as capacidades de instalação em linha (%pip ou %conda) do seu bloco de notas para instalar uma biblioteca, apenas no seu bloco de notas atual.
• Como alternativa, você pode criar um ambiente de malha, instalar bibliotecas de fontes públicas ou carregar bibliotecas personalizadas para ele e, em seguida, o administrador do espaço de trabalho pode anexar o ambiente como padrão para o espaço de trabalho. Todas as bibliotecas no ambiente ficarão disponíveis para uso em quaisquer blocos de anotações e definições de trabalho do Spark no espaço de trabalho. Para obter mais informações sobre ambientes, consulte criar, configurar e usar um ambiente no Microsoft Fabric.

Para este tutorial, use %pip install para instalar a imblearn biblioteca em seu bloco de anotações.

# Use pip to install imblearn
%pip install imblearn

Passo 2: Carregue os dados

O conjunto de dados de deteção de fraude contém transações com cartões de crédito, de setembro de 2013, que os titulares de cartões europeus efetuaram ao longo de dois dias. O conjunto de dados contém apenas recursos numéricos devido a uma transformação de Análise de Componentes Principais (PCA) aplicada aos recursos originais. A PCA transformou todos os recursos, exceto para Time e Amount. Para proteger a confidencialidade, não podemos fornecer os recursos originais ou mais informações básicas sobre o conjunto de dados.

Estes detalhes descrevem o conjunto de dados:

• As V1características , , , ..., V2V3V28 são os principais componentes obtidos com a ACP
• O Time recurso contém os segundos decorridos entre uma transação e a primeira transação no conjunto de dados
• O Amount recurso é o valor da transação. Você pode usar esse recurso para aprendizagem dependente de custos e dependente de custos
• A Class coluna é a variável de resposta (destino). Tem o valor 1 para a fraude, e 0 de outra forma

Apenas 492 transações, de um total de 284.807 transações, são fraudulentas. O conjunto de dados é altamente desequilibrado, porque a classe minoritária (fraudulenta) representa apenas cerca de 0,172% dos dados.

Esta tabela mostra uma pré-visualização dos creditcard.csv dados:

Faça o download do conjunto de dados e faça o upload para a casa do lago

Defina estes parâmetros, para que possa utilizar este bloco de notas com diferentes conjuntos de dados:

IS_CUSTOM_DATA = False  # If True, the dataset has to be uploaded manually

TARGET_COL = "Class"  # Target column name
IS_SAMPLE = False  # If True, use only <SAMPLE_ROWS> rows of data for training; otherwise, use all data
SAMPLE_ROWS = 5000  # If IS_SAMPLE is True, use only this number of rows for training

DATA_FOLDER = "Files/fraud-detection/"  # Folder with data files
DATA_FILE = "creditcard.csv"  # Data file name

EXPERIMENT_NAME = "aisample-fraud"  # MLflow experiment name

Esse código baixa uma versão disponível publicamente do conjunto de dados e, em seguida, armazena-o em uma casa de lago de malha.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        raise FileNotFoundError("Default lakehouse not found, please add a lakehouse and restart the session.")
    os.makedirs(download_path, exist_ok=True)
    if not os.path.exists(f"{download_path}/{fname}"):
        r = requests.get(f"{remote_url}/{fname}", timeout=30)
        with open(f"{download_path}/{fname}", "wb") as f:
            f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

Configurar o rastreamento de experimentos MLflow

O processo de rastreamento de experimentos salva todas as informações relevantes relacionadas ao experimento para cada experimento executado. Às vezes, você não tem como obter melhores resultados quando executa um experimento específico. Nesses casos, você deve parar o experimento e tentar um novo.

A experiência Synapse Data Science no Microsoft Fabric inclui um recurso de registro automático. Esse recurso reduz a quantidade de código necessária para registrar automaticamente os parâmetros, métricas e itens de um modelo de aprendizado de máquina durante o treinamento. O recurso estende os recursos de registro automático do MLflow. Tem profunda integração na experiência de Data Science.

Com o registro automático, você pode facilmente rastrear e comparar o desempenho de diferentes modelos e experimentos, sem a necessidade de rastreamento manual. Para obter mais informações, consulte Registro automático no Microsoft Fabric.

Para desativar o registro automático do Microsoft Fabric em uma sessão de bloco de anotações, chame mlflow.autolog() e defina disable=True:

# Set up MLflow for experiment tracking
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Leia dados brutos da casa do lago

Este código lê dados brutos da casa do lago:

df = (
    spark.read.format("csv")
    .option("header", "true")
    .option("inferSchema", True)
    .load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
    .cache()
)

Etapa 3: Executar a análise exploratória de dados

Nesta seção, você primeiro explora os dados brutos e as estatísticas de alto nível. Em seguida, para transformar os dados, converta as colunas nos tipos corretos e converta-as do Spark DataFrame em um DataFrame pandas para facilitar a visualização. Finalmente, você explora e visualiza as distribuições de classe nos dados.

Exibir os dados brutos

1. Explore os dados brutos e visualize estatísticas de alto nível com o display comando. Para obter mais informações sobre visualização de dados, consulte Visualização de bloco de anotações no Microsoft Fabric.

   display(df)
   

2. Imprima algumas informações básicas sobre o conjunto de dados:

   # Print dataset basic information
   print("records read: " + str(df.count()))
   print("Schema: ")
   df.printSchema()
   

Transformar os dados

1. Converta as colunas do conjunto de dados nos tipos corretos:

   import pyspark.sql.functions as F
   
   df_columns = df.columns
   df_columns.remove(TARGET_COL)
   
   # Ensure that TARGET_COL is the last column
   df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int"))
   
   if IS_SAMPLE:
       df = df.limit(SAMPLE_ROWS)
   

2. Converta o Spark DataFrame em um Pandas DataFrame para facilitar a visualização e o processamento:

   df_pd = df.toPandas()
   

Explore a distribuição de classes no conjunto de dados

1. Exiba a distribuição de classes no conjunto de dados:

   # The distribution of classes in the dataset
   print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset')
   print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')
   

   O código retorna esta distribuição de classe do conjunto de dados: 99,83% e 0,17% No Frauds Frauds. Essa distribuição de classe mostra que a maioria das transações não é fraudulenta. Portanto, o pré-processamento de dados é necessário antes do treinamento do modelo, para evitar sobreajuste.

2. Use um gráfico para mostrar o desequilíbrio de classe no conjunto de dados, exibindo a distribuição de transações fraudulentas versus não fraudulentas:

   import seaborn as sns
   import matplotlib.pyplot as plt
   
   colors = ["#0101DF", "#DF0101"]
   sns.countplot(x='Class', data=df_pd, palette=colors) 
   plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)
   

3. Mostre o resumo de cinco números (pontuação mínima, primeiro quartil, mediana, terceiro quartil e pontuação máxima) para o valor da transação, com gráficos de caixa:

   fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5))
   s = sns.boxplot(ax = ax1, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=True) # Remove outliers from the plot
   s = sns.boxplot(ax = ax2, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=False) # Keep outliers from the plot
   plt.show()
   

   Para dados altamente desequilibrados, os gráficos de caixa podem não mostrar informações precisas. No entanto, você pode resolver o problema do Class desequilíbrio primeiro e, em seguida, criar os mesmos gráficos para obter informações mais precisas.

Passo 4: Treinar e avaliar os modelos

Aqui, você treina um modelo LightGBM para classificar as transações fraudulentas. Você treina um modelo LightGBM no conjunto de dados desequilibrado e no conjunto de dados balanceado. Em seguida, você compara o desempenho de ambos os modelos.

Preparar conjuntos de dados de treinamento e teste

Antes do treinamento, divida os dados nos conjuntos de dados de treinamento e teste:

# Split the dataset into training and testing sets
from sklearn.model_selection import train_test_split

train, test = train_test_split(df_pd, test_size=0.15)
feature_cols = [c for c in df_pd.columns.tolist() if c not in [TARGET_COL]]

Aplicar SMOTE ao conjunto de dados de treinamento

A imblearn biblioteca utiliza a abordagem SMOTE (Synthetic Minority Oversampling Technique) para resolver o problema da classificação desequilibrada. A classificação desequilibrada acontece quando poucos exemplos da classe minoritária estão disponíveis, para que um modelo aprenda efetivamente o limite de decisão. SMOTE é a abordagem mais utilizada para sintetizar novas amostras para a classe minoritária.

Aplique o SMOTE somente ao conjunto de dados de treinamento, em vez do conjunto de dados de teste. Ao pontuar o modelo com os dados de teste, você precisa de uma aproximação do desempenho do modelo em dados invisíveis na produção. Para uma aproximação válida, os dados de teste dependem da distribuição desequilibrada original para representar os dados de produção o mais próximo possível.

# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE

X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))

new_train = pd.concat([X_res, y_res], axis=1)

Para obter mais informações sobre o SMOTE, consulte a página de referência scikit-learn para o método SMOTE e o guia do usuário scikit-learn sobre recursos de sobreamostragem.

Treine modelos de aprendizado de máquina e execute experimentos

O Apache Spark, no Microsoft Fabric, permite o aprendizado de máquina com big data. Com o Apache Spark, você pode obter informações valiosas de grandes quantidades de dados estruturados, não estruturados e em rápida movimentação.

Você tem várias opções disponíveis para treinar modelos de aprendizado de máquina com o Apache Spark no Microsoft Fabric: Apache Spark MLlib, SynapseML e outras bibliotecas de código aberto. Para obter mais informações, consulte Treinar modelos de aprendizado de máquina no Microsoft Fabric.

Um experimento de aprendizado de máquina serve como a principal unidade de organização e controle para todas as execuções de aprendizado de máquina relacionadas. Uma execução corresponde a uma única execução do código do modelo. O rastreamento de experimentos de aprendizado de máquina envolve o gerenciamento de todos os experimentos e seus componentes, como parâmetros, métricas, modelos e outros artefatos.

Para o acompanhamento de experimentos, você pode organizar todos os componentes necessários de um experimento de aprendizado de máquina específico. Além disso, você pode reproduzir facilmente resultados anteriores com experimentos salvos. Para obter mais informações sobre experimentos de aprendizado de máquina, consulte Experimentos de aprendizado de máquina no Microsoft Fabric.

1. Para controlar mais métricas, parâmetros e arquivos, defina exclusive=False para atualizar a configuração de registro automático do MLflow:

   mlflow.autolog(exclusive=False)
   

2. Treine dois modelos com LightGBM. Um modelo lida com o conjunto de dados desequilibrado e o outro modelo lida com o conjunto de dados balanceado (via SMOTE). Em seguida, compare o desempenho dos dois modelos.

   import lightgbm as lgb
   
   model = lgb.LGBMClassifier(objective="binary") # Imbalanced dataset
   smote_model = lgb.LGBMClassifier(objective="binary") # Balanced dataset
   

   # Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics
   print("Start training with imbalanced data:\n")
   with mlflow.start_run(run_name="raw_data") as raw_run:
       model = model.fit(
           train[feature_cols],
           train[TARGET_COL],
           eval_set=[(test[feature_cols], test[TARGET_COL])],
           eval_metric="auc",
           callbacks=[
               lgb.log_evaluation(10),
           ],
       )
   
   print(f"\n\nStart training with balanced data:\n")
   with mlflow.start_run(run_name="smote_data") as smote_run:
       smote_model = smote_model.fit(
           new_train[feature_cols],
           new_train[TARGET_COL],
           eval_set=[(test[feature_cols], test[TARGET_COL])],
           eval_metric="auc",
           callbacks=[
               lgb.log_evaluation(10),
           ],
       )
   

Determinar a importância do recurso para o treinamento

1. Determine a importância do recurso para o modelo que você treinou no conjunto de dados desequilibrado:

   with mlflow.start_run(run_id=raw_run.info.run_id):
       importance = lgb.plot_importance(
           model, title="Feature importance for imbalanced data"
       )
       importance.figure.savefig("feauture_importance.png")
       mlflow.log_figure(importance.figure, "feature_importance.png")
   

2. Determine a importância do recurso para o modelo que você treinou em dados balanceados. SMOTE gerou os dados balanceados:

   with mlflow.start_run(run_id=smote_run.info.run_id):
       smote_importance = lgb.plot_importance(
           smote_model, title="Feature importance for balanced (via SMOTE) data"
       )
       smote_importance.figure.savefig("feauture_importance_smote.png")
       mlflow.log_figure(smote_importance.figure, "feauture_importance_smote.png")
   

Para treinar um modelo com o conjunto de dados desequilibrado, os recursos importantes têm diferenças significativas quando comparados com um modelo treinado com o conjunto de dados balanceado.

Avaliar os modelos

Aqui, você avalia os dois modelos treinados:

• model treinado em dados brutos e desequilibrados
• smote_model treinado em dados balanceados

Métricas do modelo de computação

1. Defina uma prediction_to_spark função que execute previsões e converta os resultados da previsão em um Spark DataFrame. Em seguida, você pode calcular as estatísticas do modelo sobre os resultados da previsão com SynapseML.

   from pyspark.sql.functions import col
   from pyspark.sql.types import IntegerType, DoubleType
   
   def prediction_to_spark(model, test):
       predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
       predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
       dataColumns = [TARGET_COL, "prediction"]
       predictions = (
           spark.createDataFrame(data=predictions, schema=dataColumns)
           .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
           .withColumn("prediction", col("prediction").cast(DoubleType()))
       )
   
       return predictions
   

2. Use a prediction_to_spark função para realizar previsões com os dois modelos model e smote_model:

   predictions = prediction_to_spark(model, test)
   smote_predictions = prediction_to_spark(smote_model, test)
   predictions.limit(10).toPandas()
   

3. Métricas de computação para os dois modelos:

   from synapse.ml.train import ComputeModelStatistics
   
   metrics = ComputeModelStatistics(
       evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
   ).transform(predictions)
   
   smote_metrics = ComputeModelStatistics(
       evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
   ).transform(smote_predictions)
   display(metrics)
   

Avalie o desempenho do modelo com uma matriz de confusão

Uma matriz de confusão exibe o número de

• verdadeiros positivos (TP)
• negativos verdadeiros (TN)
• falsos positivos (PF)
• falsos negativos (FN)

que um modelo produz quando pontuado com dados de teste. Para classificação binária, o modelo retorna uma 2x2 matriz de confusão. Para classificação multiclasse, o modelo retorna uma nxn matriz de confusão, onde n é o número de classes.

1. Use uma matriz de confusão para resumir os desempenhos dos modelos de aprendizado de máquina treinados nos dados de teste:

   # Collect confusion matrix values
   cm = metrics.select("confusion_matrix").collect()[0][0].toArray()
   smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray()
   print(cm)
   

2. Plotar a matriz de confusão para as previsões de smote_model (treinadas em dados equilibrados):

   # Plot the confusion matrix
   import seaborn as sns
   
   def plot(cm):
       """
       Plot the confusion matrix.
       """
       sns.set(rc={"figure.figsize": (5, 3.5)})
       ax = sns.heatmap(cm, annot=True, fmt=".20g")
       ax.set_title("Confusion Matrix")
       ax.set_xlabel("Predicted label")
       ax.set_ylabel("True label")
       return ax
   
   with mlflow.start_run(run_id=smote_run.info.run_id):
       ax = plot(smote_cm)
       mlflow.log_figure(ax.figure, "ConfusionMatrix.png")
   

3. Plote a matriz de confusão para as previsões de model (treinadas em dados brutos e desequilibrados):

   with mlflow.start_run(run_id=raw_run.info.run_id):
       ax = plot(cm)
       mlflow.log_figure(ax.figure, "ConfusionMatrix.png")
   

Avalie o desempenho do modelo com medidas AUC-ROC e AUPRC

A medida Area Under the Curve Receiver Operating Characteristic (AUC-ROC) avalia o desempenho dos classificadores binários. O gráfico AUC-ROC visualiza o trade-off entre a taxa de verdadeiro positivo (TPR) e a taxa de falso positivo (FPR).

Em alguns casos, é mais apropriado avaliar o classificador com base na medida da Área sob a Curva de Precisão-Recordação (AUPRC). A curva AUPRC combina estas taxas:

• A precisão, ou o valor preditivo positivo (VPP)
• O recall, ou TPR

Para avaliar o desempenho com as medidas AUC-ROC e AUPRC:

1. Defina uma função que retorne as medidas AUC-ROC e AUPRC:

   from pyspark.ml.evaluation import BinaryClassificationEvaluator
   
   def evaluate(predictions):
       """
       Evaluate the model by computing AUROC and AUPRC with the predictions.
       """
   
       # Initialize the binary evaluator
       evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL)
   
       _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions)
   
       # Calculate AUROC, baseline 0.5
       auroc = _evaluator("areaUnderROC")
       print(f"The AUROC is: {auroc:.4f}")
   
       # Calculate AUPRC, baseline positive rate (0.172% in the data)
       auprc = _evaluator("areaUnderPR")
       print(f"The AUPRC is: {auprc:.4f}")
   
       return auroc, auprc    
   

2. Registre as métricas AUC-ROC e AUPRC para o modelo que você treinou em dados desequilibrados:

   with mlflow.start_run(run_id=raw_run.info.run_id):
       auroc, auprc = evaluate(predictions)
       mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
       mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})
   

3. Registre as métricas AUC-ROC e AUPRC para o modelo que você treinou em dados balanceados:

   with mlflow.start_run(run_id=smote_run.info.run_id):
       auroc, auprc = evaluate(smote_predictions)
       mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
       mlflow.log_params({"Data_Enhancement": "SMOTE", "DATA_FILE": DATA_FILE})
   

O modelo treinado nos dados balanceados retorna valores mais altos de AUC-ROC e AUPRC em comparação com o modelo treinado nos dados desequilibrados. Com base nessas medidas, o SMOTE parece ser uma técnica eficaz para melhorar o desempenho do modelo ao trabalhar com dados altamente desequilibrados.

Como mostra a imagem seguinte, qualquer experimento é registrado com seu respetivo nome. Você pode acompanhar os parâmetros do experimento e as métricas de desempenho em seu espaço de trabalho.

Esta imagem mostra as métricas de desempenho para o modelo treinado no conjunto de dados balanceado (na Versão 2):

Você pode selecionar Versão 1 para ver as métricas do modelo treinado no conjunto de dados desequilibrado. Quando você compara as métricas, o AUROC é maior para o modelo treinado com o conjunto de dados balanceado. Estes resultados indicam que este modelo é melhor em prever 0 corretamente classes como , e prever 1 classes como 01.

Passo 5: Registar os modelos

Use MLflow para registrar os dois modelos:

# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"

raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)

smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)

Etapa 6: salvar os resultados da previsão

O Microsoft Fabric permite que os usuários operacionalizem modelos de aprendizado de máquina com a PREDICT função escalável. Esta função suporta pontuação em lote (ou inferência em lote) em qualquer mecanismo de computação.

Você pode gerar previsões em lote diretamente do bloco de anotações do Microsoft Fabric ou da página de item de um modelo. Para obter mais informações sobre PREDICTo , consulte Pontuação de modelo com PREDICT no Microsoft Fabric.

1. Carregue o modelo com melhor desempenho (Versão 2) para pontuação em lote e gere os resultados da previsão:

   from synapse.ml.predict import MLFlowTransformer
   
   spark.conf.set("spark.synapse.ml.predict.enabled", "true")
   
   model = MLFlowTransformer(
       inputCols=feature_cols,
       outputCol="prediction",
       modelName=f"{EXPERIMENT_NAME}-lightgbm",
       modelVersion=2,
   )
   
   test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list())
   
   batch_predictions = model.transform(test_spark)
   

2. Guarde previsões para a casa do lago:

   # Save the predictions to the lakehouse
   batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")
   

Conteúdos relacionados

• Como usar blocos de anotações do Microsoft Fabric
• Modelo de aprendizado de máquina no Microsoft Fabric
• Preparar modelos de machine learning
• Experiências de aprendizagem automática no Microsoft Fabric