Tutorial: Criar, avaliar e pontuar um modelo de detecção de fraude
Este tutorial apresenta um exemplo de ponta a ponta de um fluxo de trabalho de Ciência de Dados do Synapse, no Microsoft Fabric. O cenário cria um modelo de detecção de fraudes com algoritmos de aprendizado de máquina treinados em dados históricos. Em seguida, ele usa o modelo para detectar futuras transações fraudulentas.
Este tutorial aborda estas etapas:
- Instalar bibliotecas personalizadas
- Carregar os dados
- Entender e processar os dados por meio da análise de dados exploratória
- Use o scikit-learn para treinar um modelo de machine learning e acompanhar experimentos com os recursos de registro automático do MLflow e do Fabric
- Salvar e registrar o modelo de machine learning que tem o melhor desempenho
- Carregar o modelo de machine learning para pontuar e fazer previsões
Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para um teste gratuito do Microsoft Fabric.
Entre no Microsoft Fabric.
Utilize o alternador de experiência na parte inferior esquerda da sua página inicial para alternar para o Fabric.
- Se necessário, crie um lakehouse do Microsoft Fabric, conforme descrito em Criar um lakehouse no Microsoft Fabric.
Você pode escolher uma destas opções para acompanhar em um caderno.
- Abra e execute o notebook integrado.
- Carregue seu bloco de anotações no GitHub.
O notebook de exemplo Detecção de fraude acompanha este tutorial.
Para abrir o bloco de anotações de exemplo para este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados.
Certifique-se de anexar um lakehouse ao notebook antes de começar a executar o código.
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 workspace.
Se você prefere copiar e colar o código desta página, pode criar um notebook.
Certifique-se de anexar um lakehouse ao notebook antes de começar a executar o código.
Para desenvolvimento de modelo de machine learning 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.
- Use as funcionalidades de instalação embutida (
%pipou%conda) do seu notebook para instalar uma biblioteca, apenas no notebook atual. - Como alternativa, você pode criar um ambiente do Fabric, instalar bibliotecas de fontes públicas ou carregar bibliotecas personalizadas nele e, em seguida, o administrador do workspace pode anexar o ambiente como o padrão para o workspace. Todas as bibliotecas no ambiente ficarão disponíveis para uso em blocos de anotações e definições de tarefas 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 biblioteca de imblearn em seu notebook.
Observação
O kernel do PySpark é reiniciado após a execução do %pip install. Instale as bibliotecas necessárias antes de executar outras células.
# Use pip to install imblearn
%pip install imblearn
O conjunto de dados de detecção de fraudes contém transações de cartão de crédito, a partir de setembro de 2013, que os titulares de cartão europeus fizeram ao longo de dois dias. O conjunto de dados contém apenas recursos numéricos devido a uma transformação PCA (Análise de Componente Principal) aplicada aos recursos originais. O PCA transformou todas as características, exceto Time e Amount. Para proteger a confidencialidade, não podemos fornecer os recursos originais ou mais informações em segundo plano sobre o conjunto de dados.
Estes detalhes descrevem o conjunto de dados:
- Os recursos
V1,V2,V3, ...,V28são os principais componentes obtidos com o PCA - O recurso
Timecontém os segundos decorridos entre uma transação e a primeira transação no conjunto de dados - O recurso
Amounté o valor da transação. Você pode usar esse recurso para um aprendizado dependente de exemplo e sensível ao custo - A coluna
Classé a variável de resposta (destino). Ele tem o valor1para fraude e0caso contrário
Apenas 492 transações, do total de 284.807 transações, são fraudulentas. O conjunto de dados está altamente desequilibrado, pois a classe minoritária (fraudulenta) representa apenas cerca de 0,172% dos dados.
Esta tabela mostra uma visualização dos dados de creditcard.csv:
| Hora | V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 | V11 | V12 | V13 | V14 | V15 | V16 | V17 | V18 | V19 | V20 | V21 | V22 | V23 | V24 | V25 | V26 | V27 | V28 | Quantidade | Classe |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | -1.3598071336738 | -0.0727811733098497 | 2.53634673796914 | 1,37815522427443 | -0.338320769942518 | 0.462387777762292 | 0.239598554061257 | 0.0986979012610507 | 0.363786969611213 | 0.0907941719789316 | -0.551599533260813 | -0.617800855762348 | -0.991389847235408 | -0.311169353699879 | 1.46817697209427 | -0.470400525259478 | 0.207971241929242 | 0.0257905801985591 | 0.403992960255733 | 0.251412098239705 | -0.018306777944153 | 0.277837575558899 | -0.110473910188767 | 0.0669280749146731 | 0.128539358273528 | -0.189114843888824 | 0.133558376740387 | -0.0210530534538215 | 149.62 | "0" |
| 0 | 1.19185711131486 | 0.26615071205963 | 0.16648011335321 | 0.448154078460911 | 0.0600176492822243 | -0.0823608088155687 | -0.0788029833323113 | 0.0851016549148104 | -0.255425128109186 | -0.166974414004614 | 1.61272666105479 | 1.06523531137287 | 0.48909501589608 | -0.143772296441519 | 0.635558093258208 | 0.463917041022171 | -0.114804663102346 | -0.183361270123994 | -0.145783041325259 | -0.0690831352230203 | -0.225775248033138 | -0.638671952771851 | 0.101288021253234 | -0.339846475529127 | 0.167170404418143 | 0.125894532368176 | -0.00898309914322813 | 0.0147241691924927 | 2.69 | "0" |
Defina esses parâmetros para que você possa usar este notebook com conjuntos de dados diferentes:
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-a em um lakehouse do Fabric.
Importante
Certifique-se de adicionar um lakehouse ao notebook antes de executá-lo. Caso contrário, você receberá um erro.
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.")
O processo de acompanhamento de experimento salva todas as informações relevantes relacionadas a experimentos para cada experimento executado. Às vezes, você não tem como obter melhores resultados ao executar um experimento específico. Nesses casos, você deve parar o experimento e tentar um novo.
A experiência de Ciência de Dados do Synapse 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, as métricas e os itens de um modelo de machine learning durante o treinamento. O recurso estende os recursos de registro automático do MLflow. Ele tem integração profunda na experiência de Ciência de Dados.
Com o registro automático, você pode acompanhar e comparar facilmente o desempenho de diferentes modelos e experimentos, sem a necessidade de acompanhamento manual. Para obter mais informações, confira Log automático no Microsoft Fabric.
Para desabilitar o registro automático do Microsoft Fabric em uma sessão de notebook, 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
Esse código lê dados brutos do lakehouse:
df = (
spark.read.format("csv")
.option("header", "true")
.option("inferSchema", True)
.load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
.cache()
)
Nesta seção, primeiro você explorará 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 DataFrame do Spark em um DataFrame pandas para facilitar a visualização. Por fim, você explora e visualiza as distribuições de classe nos dados.
Explore os dados brutos e exiba estatísticas de alto nível com o comando
display. Para obter mais informações sobre visualização de dados, consulte Visualização do notebook no Microsoft Fabric.display(df)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()
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)Converta o DataFrame do Spark em um DataFrame do Pandas para facilitar a visualização e o processamento:
df_pd = df.toPandas()
Exiba a distribuição de classe 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 essa distribuição de classe de conjunto de dados: 99,83%
No Fraudse 0,17%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 o sobreajuste.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)Mostre o resumo de cinco números (a pontuação mínima, o primeiro quartil, a mediana, o terceiro quartil e a 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 desbalanceados, os gráficos de caixa podem não mostrar insights precisos. No entanto, você pode resolver o problema de desequilíbrio
Classprimeiro e, em seguida, criar os mesmos gráficos para insights mais precisos.
Aqui, você treina um modelo LightGBM para classificar as transações de fraude. Você treina um modelo LightGBM no conjunto de dados desbalanceado e no conjunto de dados balanceado. Em seguida, você compara o desempenho de ambos os modelos.
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]]
A biblioteca imblearn usa a abordagem SMOTE (técnica de sobreamostragem de minoria sintética) para resolver o problema de classificação desbalanceada. A classificação desequilibrada ocorre 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 usada para sintetizar novos exemplos para a classe minoritária.
Aplique 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ê precisará de uma aproximação do desempenho do modelo em dados não vistos na produção. Para uma aproximação válida, seus 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 os recursos página de referência do scikit-learn para o método SMOTE e o guia do usuário scikit-learn sobre sobresamostragem.
O Apache Spark, no Microsoft Fabric, habilita o aprendizado de máquina com Big Data. Com o Apache Spark, você pode obter insights valiosos de grandes quantidades de dados estruturados, não estruturados e rápidos.
Você tem várias opções disponíveis para treinar modelos de machine learning com o Apache Spark no Microsoft Fabric: Apache Spark MLlib, SynapseML e outras bibliotecas de software livre. Para obter mais informações, consulte Treinar modelos de machine learning 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 aprendizado de máquina de acompanhamento de experimentos envolve o gerenciamento de todos os experimentos e seus componentes, como parâmetros, métricas, modelos e outros artefatos.
Para acompanhamento de experimentos, você pode organizar todos os componentes necessários de um experimento de machine learning específico. Além disso, você pode reproduzir facilmente resultados passados com experimentos salvos. Para obter mais informações sobre experimentos de machine learning, consulte experimentos de machine learning no Microsoft Fabric.
Para acompanhar mais métricas, parâmetros e arquivos, defina
exclusive=Falsepara atualizar a configuração de registro automático do MLflow:mlflow.autolog(exclusive=False)Treine dois modelos com LightGBM. Um modelo manipula o conjunto de dados desequilibrado, e o outro modelo manipula 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), ], )
Determine a importância das características 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")Determine a importância da característica para o modelo que você treinou em dados balanceados. O SMOTE gerou os dados equilibrados:
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.
Aqui, você avalia os dois modelos treinados:
modeltreinados em dados brutos e desbalanceadossmote_modeltreinado em dados balanceados
Defina uma função
prediction_to_sparkque executa previsões e converte os resultados da previsão em um DataFrame do Spark. Em seguida, você pode calcular estatísticas de modelo nos 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 predictionsUse a função
prediction_to_sparkpara executar previsões com os dois modelos,modelesmote_model:predictions = prediction_to_spark(model, test) smote_predictions = prediction_to_spark(smote_model, test) predictions.limit(10).toPandas()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)
Uma matriz de confusão exibe o número de
- TPs (verdadeiros positivos)
- TNs (verdadeiros negativos)
- FPs (falsos positivos)
- FNs (falsos negativos)
que um modelo produz quando avaliado com dados de teste. Para classificação binária, o modelo retorna uma matriz de confusão 2x2. Para classificação multiclasse, o modelo retorna uma matriz de confusão nxn, em que n é o número de classes.
Use uma matriz de confusão para resumir os desempenhos dos modelos de machine learning 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)Trace a matriz de confusão para as previsões de
smote_model(treinado 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")Trace 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")
A medida AUC-ROC (Área sob a Curva da Característica de Operação do Receptor) avalia o desempenho dos classificadores binários. O gráfico AUC-ROC visualiza a compensação entre a taxa verdadeira positiva (TPR) e a taxa de falso positivo (FPR).
Em alguns casos, é mais apropriado avaliar o classificador com base na medida AUPRC (Área Sob a Curva Precision-Recall). A curva AUPRC combina estas taxas:
- A precisão ou o valor preditivo positivo (PPV)
- O recall ou TPR
Para avaliar o desempenho com as medidas AUC-ROC e AUPRC:
Defina uma função que retorna 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, auprcRegistre as métricas AUC-ROC e AUPRC para o modelo treinado em dados desbalanceados:
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})Registre as métricas AUPRC e AUC-ROC 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 equilibrados retorna valores de AUC-ROC e AUPRC mais altos 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 desequilibrado.
Como mostra a próxima imagem, qualquer experimento é registrado com seu respectivo nome. Você pode acompanhar os parâmetros de experimento e as métricas de desempenho em seu workspace.
Esta imagem mostra as métricas de desempenho do modelo treinado no conjunto de dados equilibrado (no 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. Esses resultados indicam que esse modelo é melhor em prever corretamente as classes 0 como 0e prever classes 1 como 1.
Use o 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)
O Microsoft Fabric permite que os usuários operacionalizem modelos de machine learning com a função escalonável PREDICT. Essa função dá suporte à 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 itens de um modelo. Para obter mais informações sobre PREDICT, consulte Pontuação de modelo com PREDICT no Microsoft Fabric.
Carregue o modelo de 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)Salve previsões no lakehouse:
# Save the predictions to the lakehouse batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")