Tutorial: criar, avaliar e pontuar um modelo de detecção de fraude

Artigo
02/05/2024

Este tutorial apresenta um exemplo de ponta a ponta de um fluxo de trabalho da Ciência de Dados do Synapse no Microsoft Fabric. Este cenário constrói um modelo de detecção de fraudes com algoritmos de aprendizado de máquina treinados em dados históricos. Ele então usa o modelo para detectar futuras transações fraudulentas.

Este tutorial cobre estas etapas:

Instalar bibliotecas personalizadas
Carregar os dados
Entender e processar os dados por meio da análise exploratória de dados
Use o scikit-learn para treinar um modelo de machine learning e acompanhar os experimentos usando o MLflow e o recurso de log automático do Fabric
Salvar e registrar o modelo de machine learning com o maior desempenho
Carregar o modelo de machine learning para pontuar e fazer previsões

Pré-requisitos

Obtenha uma assinatura do Microsoft Fabric. Ou, inscreva-se para uma avaliação gratuita do Microsoft Fabric.
Entre no Microsoft Fabric.
Use o seletor de experiência no lado esquerdo da sua página inicial para alternar para a experiência de Ciência de Dados do Synapse.

Se necessário, crie um lakehouse do Microsoft Fabric como está descrito em Criar um lakehouse no Microsoft Fabric.

Acompanhar em um notebook

Você pode escolher uma dessas opções para acompanhar em um notebook:

Abra e execute o Notebook interno na experiência de Ciência de Dados
Carregue seu Notebook do GitHub para a experiência de Ciência de Dados

Abrir o Notebook interno

O Notebook de amostra de detecção de fraude que acompanha este tutorial.

Para abrir o Notebook de amostra interno do tutorial na experiência de Ciência de Dados do Synapse:

Vá para a página inicial de Synapse Data Science.
Selecione Usar um exemplo.
Selecione o exemplo correspondente:
- Na guia padrão fluxos de trabalho de ponta a ponta (Python), se o exemplo for para um tutorial do Python.
- Na guia fluxos de trabalho de ponta a ponta (R), se o exemplo for para um tutorial do R.
- Na guia Tutoriais rápidos, se o exemplo for para um tutorial rápido.
Anexe um lakehouse ao notebook antes de começar a executar o código.

Importar o Notebook do GitHub

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

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

Se preferir copiar e colar o código a partir dessa página, você poderá criar um novo 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 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.

Usar os recursos de instalação embutido (%pip ou %conda) do notebook para instalar a biblioteca somente no notebook atual.
Como alternativa, você pode criar um ambiente de Fabric, 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 trabalho do Spark no espaço de trabalho. Para obter mais informações sobre ambientes, confira Criar, configurar e usar um ambiente no Microsoft Fabric.

Para este tutorial, use %pip install para instalar a biblioteca imblearn no notebook.

Observação

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

# 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, feitas por titulares de cartões europeus ao longo de dois dias. O conjunto de dados contém apenas recursos numéricos por causa de uma transformação de ACP (Análise de Componentes Principais) aplicada aos recursos originais. A ACP transformou todos os recursos, exceto o 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, ..., V28 são os componentes principais obtidos com ACP
O recurso Time 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 sensível ao custo e dependente de exemplos
A coluna Class é a variável (destino) de resposta. Tem o valor 1 para fraude, e 0 caso contrário

Apenas 492 transações, dentre um total de 284.807, são fraudulentas. O conjunto de dados está altamente desequilibrado, porque as contas de classe minoritária (fraude) representam apenas cerca de 0,172% dos dados.

A tabela mostra uma versão prévia 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	Valor	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"

Baixar o conjunto de dados e carregar no lakehouse

Defina estes parâmetros, para que você possa usar este Notebook com diferentes conjuntos de dados:

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

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

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

EXPERIMENT_NAME = "aisample-fraud"  # MLflow experiment name

Esse código faz o download de uma versão disponível publicamente do conjunto de dados e, em seguida, o armazena em um lakehouse do Fabric.

Importante

Certifique-se deAdicionar um lakehouse ao notebook antes de executá-lo. Caso contrário, você terá 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 acompanhamento de experimentos do MLflow

O acompanhamento de experimentos é o processo de salvar todas as informações relevantes para cada experimento executado. Às vezes, você não tem como obter melhores resultados quando executa um experimento específico. Em casos como esse, 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 em log 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 machine learning durante o treinamento. O recurso estende as capacidades de log automático do MLflow. Possui profunda integração na experiência de Data Science.

Com o log 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 log automático do Microsoft Fabric em uma sessão do notebook, chame mlflow.autolog() e configure como 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 exploratória de dados

Nesta seção, comece explorando 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 elas para o DataFrame do Spark em um DataFrame do pandas para facilitar a visualização. Por fim, explore e visualize as distribuições de classe nos dados.

Exibir os dados brutos

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, confira Visualização de 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()

Transformar os dados

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 DataFrame do pandas para facilitar o processamento e a visualização:
```
df_pd = df.toPandas()
```

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

Exiba a distribuição de classes no conjunto de dados:
```
# The distribution of classes in the dataset
print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset')
print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')
```
O código retorna esta distribuição de classe do conjunto de dados: 99,83% No Frauds e 0,17% Frauds. Essa distribuição de classes 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 um sobreajuste.

Use um gráfico para mostrar o desequilíbrio de classe no conjunto de dados, exibindo a distribuição de transações fraudulentas e 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 diagramas 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, esses diagramas de caixa podem não demonstrar insights precisos. No entanto, você pode resolver primeiro o problema de desequilíbrio de Class e depois criar os mesmos gráficos para obter insights mais precisos.

Etapa 4: Treinar e avaliar os modelos

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

Preparar conjuntos de dados de treinamento e teste

Antes do treinamento, divida os dados em conjuntos de dados de treinamento e de 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]]

Aplique o SMOTE ao conjunto de dados de treinamento

A biblioteca imblearn usa a abordagem SMOTE (técnica de sobreamostragem minoritária sintética) para resolver o problema de classificação desequilibrada. A classificação desequilibrada ocorre quando poucos exemplos da classe minoritária estão disponíveis para um modelo aprender efetivamente o limite de decisão. O SMOTE é a abordagem mais usada para sintetizar novos exemplos para a classe minoritária.

Aplique o SMOTE somente ao conjunto de dados de treinamento, ao invés do conjunto de dados de teste. Ao pontuar o modelo com os dados de teste, é preciso 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 da forma mais próxima 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 mais sobre o SMOTE, confira os recursos página de referência do scikit-learn para o método SMOTE e o guia do usuário do scikit-learn sobre sobreamostragem.

Treinar modelos de machine learning e executar experimentos

O Apache Spark, no Microsoft Fabric, permite 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 de movimentação rápida.

Você tem várias opções disponíveis para o treinamento de modelos de machine learning com o Apache Spark no Microsoft Fabric: Apache Spark MLlib, SynapseML e várias outras bibliotecas de código aberto. Para obter mais informações, confira 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 acompanhamento de experimentos de aprendizado de máquina involve o gerenciamento de todos os diferentes 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 aprendizado de máquina específico. Além disso, você pode reproduzir facilmente resultados passados usando experimentos salvos. Para obter mais informações sobre experimentos de aprendizado de máquina, confira Experimentos de aprendizado de máquina no Microsoft Fabric.

Para acompanhar métricas, parâmetros e arquivos adicionais, configure exclusive=False para atualizar a configuração de log automático do MLflow:
```
mlflow.autolog(exclusive=False)
```

Treine dois modelos com LightGBM. Um modelo lida com conjunto de dados desbalanceado 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

Primeiro, determine a importância do recurso para o modelo que você treinou no conjunto de dados desequilibrado:

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

Determine a importância do recurso para o modelo que você treinou no conjunto de dados equilibrados. 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, as características importantes têm diferenças significativas quando comparadas com um modelo treinado com o conjunto de dados equilibrados.

Avaliar os modelos

Aqui, avalie os dois modelos treinados:

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

Métricas do modelo de computação

Defina uma função prediction_to_spark que execute previsões e converta os resultados da previsão em um DataFrame do Spark. Você pode computar as estatísticas do modelo nos resultados da previsão com 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

Use a função prediction_to_spark para executar 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()

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

verdadeiros positivos (TP)
verdadeiros negativos (TN)
falsos positivos (FP)
falsos negativos (FN)

que um modelo produz quando pontuado com dados de teste. Para a classificação binária, o modelo retorna uma matriz de confusão 2x2. Para a 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 o desempenho 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")

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

A medida AUC-ROC (Area Under the Curve Receiver Operating Characteristic) avalia o desempenho de classificadores binários. O gráfico AUC-ROC visualiza a compensação entre a taxa de verdadeiros positivos (TPR) e a taxa de falsos positivos (FPR).

Em alguns casos, é mais apropriado avaliar seu classificador com base na medida AUPRC (Area Under the Precision-Recall Curve). A curva AUPRC combina essas 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 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

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

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

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

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 em dados equilibrados retorna valores mais altos de AUC-ROC e AUPRC em comparação com o modelo treinado em dados desequilibrados. Com base nessas medidas, o SMOTE parece ser uma técnica eficaz para aprimorar o desempenho do modelo ao trabalhar com dados altamente desequilibrados.

Conforme mostrado na imagem a seguir, qualquer experimento é registrado junto com seu respectivo nome. Você pode acompanhar os parâmetros do experimento e as métricas de desempenho em seu espaço de trabalho.

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

Você pode selecionar a Versão 1 para ver as métricas do modelo treinado no conjunto de dados desequilibrado. Ao comparar as métricas, a AUROC é maior para o modelo treinado com o conjunto de dados equilibrado. Esses resultados indicam que esse modelo é melhor em prever corretamente classes 0 como 0 e 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

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 notebook do Microsoft Fabric ou da página de itens de um determinado modelo. Para obter mais informações sobre PREDICT, confira 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)

Salvar as previsões no lakehouse:

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

Compartilhar via

Tutorial: criar, avaliar e pontuar um modelo de detecção de fraude

Pré-requisitos

Acompanhar em um notebook

Abrir o Notebook interno

Importar o Notebook do GitHub

Etapa 1: Instalar bibliotecas personalizadas

Etapa 2: Carregar os dados

Baixar o conjunto de dados e carregar no lakehouse

Configurar o acompanhamento de experimentos do MLflow

Ler dados brutos do lakehouse

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

Exibir os dados brutos

Transformar os dados

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

Etapa 4: Treinar e avaliar os modelos

Preparar conjuntos de dados de treinamento e teste

Aplique o SMOTE ao conjunto de dados de treinamento

Treinar modelos de machine learning e executar experimentos

Determinar a importância do recurso para o treinamento

Avaliar os modelos

Métricas do modelo de computação

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

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

Etapa 5: Registrar os modelos

Etapa 6: Salvar os resultados da previsão

Comentários

Recursos adicionais

Compartilhar via

Tutorial: criar, avaliar e pontuar um modelo de detecção de fraude

Pré-requisitos

Acompanhar em um notebook

Abrir o Notebook interno

Importar o Notebook do GitHub

Etapa 1: Instalar bibliotecas personalizadas

Etapa 2: Carregar os dados

Baixar o conjunto de dados e carregar no lakehouse

Configurar o acompanhamento de experimentos do MLflow

Ler dados brutos do lakehouse

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

Exibir os dados brutos

Transformar os dados

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

Etapa 4: Treinar e avaliar os modelos

Preparar conjuntos de dados de treinamento e teste

Aplique o SMOTE ao conjunto de dados de treinamento

Treinar modelos de machine learning e executar experimentos

Determinar a importância do recurso para o treinamento

Avaliar os modelos

Métricas do modelo de computação

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

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

Etapa 5: Registrar os modelos

Etapa 6: Salvar os resultados da previsão

Conteúdo relacionado

Comentários

Recursos adicionais