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, em Microsoft Fabric. O cenário cria um modelo de detecção de fraude com algoritmos de machine learning treinados em dados históricos. Em seguida, ele usa o modelo para detectar futuras transações fraudulentas.

Este tutorial aborda estas etapas:

Pré-requisitos

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

• Faça login no Microsoft Fabric.

• Alterne para o Fabric usando o alternador de experiências no canto inferior esquerdo da página inicial.

  

• Se necessário, crie uma Microsoft Fabric lakehouse, conforme descrito em Criar uma lakehouse em Microsoft Fabric.

Acompanhe em um caderno

Para acompanhar em um bloco de anotações, escolha uma destas opções:

• Abra e execute o notebook integrado.
• Carregue seu notebook do GitHub.

Abrir o bloco de anotações interno

O notebook de exemplo Detecçã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 notebook antes de começar a executar o código.

Importar o notebook do GitHub

O bloco de anotações 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.

Etapa 1: Instalar bibliotecas personalizadas

Para o desenvolvimento de modelos de machine learning ou análise de dados ad hoc, pode ser 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 (%pip ou %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 estão disponíveis para uso em blocos de anotações e definições de trabalho do Spark no workspace. 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.

# Use pip to install imblearn
%pip install imblearn

Etapa 2: Carregar os dados

O conjunto de dados de detecção de fraude contém transações de cartão de crédito 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, os recursos originais ou mais informações em segundo plano sobre o conjunto de dados não estão disponíveis.

Estes detalhes descrevem o conjunto de dados:

• Os V1, V2, V3, …, V28 são as principais características obtidas com PCA.
• O Time recurso conté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 valor 1 para fraude, e 0 para outra situação.

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:

Baixar o conjunto de dados e carregar no lakehouse

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.

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

    remote_url = "https://synapseaisolutionsa.z13.web.core.windows.net/data/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 acompanhamento de experimentos do MLflow

O processo de acompanhamento de experimento salva todas as informações relevantes relacionadas a experimentos para cada experimento executado. Às vezes, você não pode obter melhores resultados ao executar um experimento específico. Nesses casos, pare o experimento e tente 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.

Usando 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, consulte Autologging no Microsoft Fabric.

Para desabilitar Microsoft Fabric registro automático 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

Ler dados brutos do lakehouse

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

Etapa 3: executar análise de dados exploratória

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.

Exibir os dados brutos

1. Explore os dados brutos e exiba estatísticas de alto nível usando o display comando. Para obter mais informações sobre visualização de dados, consulte Notebook visualization in 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 DataFrame do Spark em um DataFrame do Pandas para facilitar a visualização e o processamento:

   df_pd = df.toPandas()
   

Explorar a distribuição de classe no conjunto de dados

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

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 (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 Class primeiro e, em seguida, criar os mesmos gráficos para insights mais precisos.

Etapa 4: Treinar e avaliar os modelos

Nesta etapa, você treinará 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.

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

Treinar modelos machine learning e executar experimentos

O Apache Spark, em Microsoft Fabric, habilita machine learning com Big Data. Usando o Apache Spark, você pode obter insights valiosos de grandes quantidades de dados estruturados, não estruturados e de movimentação rápida.

Você tem várias opções disponíveis para treinar modelos de machine learning com o Apache Spark em Microsoft Fabric: Apache Spark MLlib, SynapseML e outras bibliotecas de software livre. Para obter mais informações, consulte Treinar modelos machine learning em Microsoft Fabric.

Um experimento machine learning serve como a unidade primária de organização e controle para todas as execuções de machine learning relacionadas. Uma execução corresponde a uma única execução do código do modelo. Machine learning experiment tracking envolve o gerenciamento de todos os experimentos e seus componentes, como parâmetros, métricas, modelos e outros artifacts.

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 machine learning, consulte Machine learning experimentos em Microsoft Fabric.

1. Para acompanhar 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 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),
           ],
       )
   

Determinar a importância da característica para treinamento

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

2. 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")
   

Quando você treina um modelo com o conjunto de dados desequilibrado, os recursos importantes mostram diferenças significativas em relação a um modelo treinado com o conjunto de dados balanceado.

Avaliar os modelos

Aqui, você avalia os dois modelos treinados:

• model treinados em dados brutos e desbalanceados
• smote_model treinado em dados balanceados

Métricas do modelo de computação

1. Defina uma prediction_to_spark função que faz previsões e converte os resultados da previsão em um DataFrame do Spark. Em seguida, você pode calcular as estatísticas do modelo nos resultados da previsão usando 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 fazer 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)
   

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

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.

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

2. 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")
   

3. 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")
   

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

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:

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

2. Registre 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})
   

3. 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 imagem a seguir, o sistema registra cada experimento com seu respectivo nome. Você pode acompanhar os parâmetros de experimento e as métricas de desempenho em seu workspace.

A imagem a seguir mostra as métricas de desempenho do modelo treinado no conjunto de dados equilibrado (na versão 2):

Selecione a Versão 1 para ver as métricas do modelo treinado no conjunto de dados desequilibrado. Ao comparar as métricas, você verá que 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.

Etapa 5: Registrar os modelos

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)

Etapa 6: Salvar os resultados da previsão

Microsoft Fabric usuários podem operacionalizar modelos de machine learning usando 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 Microsoft Fabric ou da página de itens de um modelo. Para obter mais informações sobre PREDICT, veja Pontuação de Modelo com PREDICT no Microsoft Fabric.

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

2. 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")
   

Conteúdo relacionado

• Como usar blocos de anotações Microsoft Fabric
• Modelo de aprendizado de máquina no Microsoft Fabric
• Treinar modelos de aprendizado de máquina
• Experimentos de aprendizado de máquina no Microsoft Fabric