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

Este tutorial apresenta um exemplo completo de um fluxo de trabalho de Ciência de Dados Synapse, no Microsoft Fabric. O cenário constrói um modelo de deteção de fraude com algoritmos de machine learning treinados com dados históricos. Em seguida, usa o modelo para detetar futuras transações fraudulentas.

Este tutorial aborda estas etapas:

Pré-requisitos

• Faça uma subscrição Microsoft Fabric. Ou, inscreva-se para um teste gratuito Microsoft Fabric.

• Iniciar sessão em Microsoft Fabric.

• Altera para o Fabric usando o alternador de experiência no canto inferior esquerdo da sua página inicial.

  

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

Tome nota num caderno

Para acompanhar num caderno, escolha uma destas opções:

• Abra e execute o bloco de notas incorporado.
• Carrega o teu caderno 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 caderno do GitHub

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

• Para abrir o notebook que acompanha este tutorial, siga as instruções em Preparar o seu sistema para tutoriais de ciência de dados para importar o notebook para o 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 notebook antes de começar a executar o código.

Etapa 1: Instalar bibliotecas personalizadas

Para desenvolvimento de modelos de machine learning ou análise de dados ad-hoc, pode ser necessário instalar rapidamente uma biblioteca personalizada para a 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 do ambiente estão disponíveis para uso em quaisquer cadernos e definições de funções Spark no espaço de trabalho. Para mais informações sobre ambientes, consulte criar, configurar e usar um ambiente em Microsoft Fabric.

Para este tutorial, use %pip install para instalar a biblioteca imblearn no seu caderno de notas.

# 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ão de crédito de setembro de 2013 feitas pelos titulares europeus 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, as funcionalidades originais ou mais informações de fundo sobre o conjunto de dados não estão disponíveis.

Estes detalhes descrevem o conjunto de dados:

• As V1características , V2, V3, ..., V28 são os principais componentes obtidos com a PCA.
• A Time funcionalidade 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. Pode usar esta funcionalidade para aprendizagem dependente de exemplo e sensível a custos.
• A coluna Class é a variável de resposta (destino). Tem valor 1 para fraude, e 0 para outras coisas.

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:

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 usar este caderno 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.

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 rastreamento de experimentos MLflow

O processo de rastreamento de experimentos salva todas as informações relevantes relacionadas ao experimento para cada experimento executado. Por vezes, não se obtêm melhores resultados quando se executa uma experiência específica. Nesses casos, para a experiência e tenta uma nova.

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

Ao usar autologs, pode facilmente acompanhar e comparar o desempenho de diferentes modelos e experiências, sem necessidade de rastreamento manual. Para mais informações, consulte Autologging em Microsoft Fabric.

Para desativar Microsoft Fabric autolog numa 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

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 usando o display comando. Para mais informações sobre visualização de dados, consulte Visualização de cadernos em 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. Por isso, é necessário pré-processamento de dados antes do treino 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

Neste passo, 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.

Treinar modelos de machine learning e realizar experiências

O Apache Spark, no Microsoft Fabric, permite machine learning com big data. Ao usar o Apache Spark, pode obter insights valiosos a partir de grandes quantidades de dados estruturados, não estruturados e de rápida circulação.

Tem várias opções disponíveis para treinar modelos de machine learning com Apache Spark em Microsoft Fabric: Apache Spark MLlib, SynapseML e outras bibliotecas open-source. Para mais informações, consulte Treinar modelos de machine learning no Microsoft Fabric.

Uma experiência de machine learning serve como a unidade principal 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 acompanhamento de experiências envolve a gestão de todos os experimentos e seus componentes, como parâmetros, métricas, modelos e outros artifacts.

Para o acompanhamento de experiências, pode organizar todos os componentes necessários de uma experiência específica de machine learning. Além disso, você pode reproduzir facilmente resultados anteriores com experimentos salvos. Para mais informações sobre experiências de aprendizagem automática, consulte experiências de aprendizagem automática na 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")
   

Quando treina um modelo com o conjunto de dados desequilibrado, as características importantes mostram diferenças significativas em comparação com um modelo treinado com o conjunto de dados equilibrado.

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 faça previsões e converta os resultados das previsões num DataFrame Spark. Pode então calcular estatísticas do modelo com base nos resultados da previsão usando o 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)
   

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. Utilize uma matriz de confusão para resumir o desempenho dos modelos treinados de machine learning 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, o sistema regista cada experimento com o respetivo nome. Você pode acompanhar os parâmetros do experimento e as métricas de desempenho em seu espaço de trabalho.

A imagem seguinte mostra as métricas de desempenho do modelo treinado no conjunto de dados balanceado (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, vê-se que o AUROC é mais elevado 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

Microsoft Fabric utilizadores podem operacionalizar machine learning modelos utilizando a função escalável PREDICT. Esta função suporta pontuação em lote (ou inferência em lote) em qualquer mecanismo de computação.

Pode gerar previsões em lote diretamente a partir do portátil Microsoft Fabric ou da página de item de um modelo. Para mais informações sobre PREDICT, consulte Avaliação do 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

• Como usar Microsoft Fabric cadernos
• Modelo de aprendizagem automática no Microsoft Fabric
• Treinar modelos de machine learning
• Experimentos de aprendizagem automática no Microsoft Fabric