Partilhar via

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

  • Artigo

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:

  • Instalar bibliotecas personalizadas
  • Carregue os dados
  • Compreender e processar os dados através da análise exploratória de dados
  • Use o scikit-learn para treinar um modelo de aprendizado de máquina e acompanhe experimentos com os recursos MLflow e Fabric Autologging
  • Salve e registre o modelo de aprendizado de máquina que tem o mais alto desempenho
  • Carregue o modelo de aprendizado de máquina para pontuar e fazer previsões

Pré-requisitos

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

  • Entre no Microsoft Fabric.

  • Use o seletor de experiência no canto inferior esquerdo da página inicial para alternar para o Fabric.

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

Tome nota num caderno

Você pode escolher uma destas opções para acompanhar num caderno:

  • Abra e execute o bloco de notas incorporado.
  • Carregue seu bloco de anotações do GitHub.

Abra o bloco de notas incorporado

O caderno Deteção de fraude acompanha este tutorial.

  1. 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.

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

Importar o notebook do GitHub

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

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 notebooks 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 imblearn no seu caderno de notas.

Observação

O kernel do PySpark é reiniciado após a execução %pip install. Instale as bibliotecas necessárias antes de executar quaisquer outras células.

# 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 todas as características, exceto 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 variáveis V1, V2, V3, ..., V28 são os componentes principais obtidos com a ACP
  • O recurso Time contém os segundos decorridos entre uma transação e a primeira transação no conjunto de dados
  • A Amount característica é o valor da transação. Você pode usar esse recurso para aprendizagem exemplo-dependente e sensível a custos.
  • A coluna Class é a variável de resposta (destino). Tem o valor 1 para fraudes e 0 caso contrário

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 dados 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 Montante 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"

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

Este código descarrega uma versão publicamente disponível do conjunto de dados e, em seguida, armazena-o numa lakehouse de Fabric.

Importante

Certifique-se de adicionar um lakehouse ao bloco de anotações 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.")

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 desabilitar 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, atribua os tipos corretos às colunas e converta-as do Spark DataFrame para um DataFrame do pandas para uma visualização mais fácil. 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 comando display. Para obter mais informações sobre visualização de dados, consulte visualização do 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 essa distribuição de classe de conjunto de dados: 99,83% No Frauds e 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 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 de desequilíbrio Class 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 biblioteca imblearn usa 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 do scikit-learn para o do método SMOTE e o guia do usuário do scikit-learn sobre sobreamostragem recursos.

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 aprendizado de máquina de rastreamento de experimentos 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 da característica para o modelo que treinou no conjunto de dados desbalanceado.

    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 da característica para o modelo treinado 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 função prediction_to_spark 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 função prediction_to_spark 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 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, 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. Elaborar a matriz de confusão para as previsões do modelo model (treinado 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 da Área Sob a Curva Característica de Operação do Recetor (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 Precision-Recall (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 de 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.

Captura de tela do experimento rastreado.

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

Captura de tela das métricas de desempenho do modelo registrado e dos parâmetros do modelo.

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 corretamente 0 classes como 0e prever 1 classes como 1.

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 função PREDICT 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 PREDICT, 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údo relacionado