Tutorial: creación, evaluación y puntuación de un modelo de detección de fraudes

Artículo
02/01/2024

En este tutorial se presenta un ejemplo completo de un flujo de trabajo de ciencia de datos de Synapse en Microsoft Fabric. En el escenario se crea un modelo de detección de fraudes mediante algoritmos de aprendizaje automático entrenados en datos históricos. A continuación, se usa el modelo para detectar transacciones fraudulentas futuras.

En este tutorial se describen estos pasos:

Instalación de bibliotecas personalizadas
Carga de los datos
Comprender y procesar los datos a través de un análisis de datos exploratorio
Use scikit-learn para entrenar un modelo de Machine Learning y realizar un seguimiento de los experimentos mediante las características de registro automático de MLflow y Fabric.
Guardar y registrar el modelo de Machine Learning con mejor rendimiento
Cargar el modelo de Machine Learning para puntuar y realizar predicciones

Requisitos previos

Obtenga una suscripción a Microsoft Fabric. También puede registrarse para obtener una evaluación gratuita de Microsoft Fabric.
Inicie sesión en Microsoft Fabric.
Use el conmutador de experiencia en el lado izquierdo de la página principal para cambiar a la experiencia de ciencia de datos de Synapse.

Si es necesario, cree un almacén de lago de Microsoft Fabric como se describe en Creación de un almacén de lago en Microsoft Fabric.

Seguir en un cuaderno

Puede elegir una de estas opciones para seguir en un cuaderno:

Abra y ejecute el cuaderno integrado en la experiencia de ciencia de datos
Cargue su cuaderno desde GitHub a la experiencia de ciencia de datos

Abra el cuaderno integrado

El cuaderno de muestra Fraud detection acompaña a este tutorial.

Para abrir el cuaderno de muestra integrado en el tutorial en la experiencia de ciencia de datos de Synapse:

Vaya a la página principal de ciencia de datos de Synapse.
Seleccione Utilizar una muestra.
Seleccione la muestra correspondiente:
- Desde la pestaña predeterminada Flujos de trabajo de un extremo a otro (Python), si la muestra es para un tutorial de Python.
- Desde la pestaña Flujos de trabajo de un extremo a otro (R), si la muestra es para un tutorial de R.
- En la pestaña Tutoriales rápidos, si la muestra es para un tutorial rápido.
Adjunte una instancia de LakeHouse al cuaderno antes de empezar a ejecutar código.

Importación del cuaderno desde GitHub

El cuaderno AIsample - Fraud Detection.ipynb acompaña a este tutorial.

Para abrir el cuaderno complementario para este tutorial, siga las instrucciones en Preparación del sistema para los tutoriales de ciencia de datos para importar el cuaderno en el área de trabajo.

Si prefiere copiar y pegar el código de esta página, puede crear un cuaderno nuevo.

Asegúrese de adjuntar una instancia de LakeHouse al cuaderno antes de empezar a ejecutar código.

Paso 1: Instalación de bibliotecas personalizadas

Para desarrollar modelos de Machine Learning o realizar análisis de datos ad hoc, es posible que tenga que instalar rápidamente una biblioteca personalizada para la sesión de Apache Spark. Tiene dos opciones para instalar bibliotecas.

Use las funcionalidades de instalación insertadas (%pip o %conda) del cuaderno para instalar una biblioteca solo en el cuaderno actual.
Como alternativa, puede crear un entorno de Fabric, instalar bibliotecas desde orígenes públicos o cargar bibliotecas personalizadas en él y, después, el administrador del área de trabajo puede asociar el entorno como valor predeterminado para el área de trabajo. Todas las bibliotecas del entorno estarán disponibles para su uso en los cuadernos y las definiciones de trabajo de Spark del área de trabajo. Para obtener más información sobre los entornos, consulte Creación, configuración y uso de un entorno en Microsoft Fabric.

En este tutorial, usará %pip install para instalar la biblioteca imblearn en el cuaderno.

Nota:

El kernel de PySpark se reiniciará después de %pip install ejecuciones. Si lo necesita, instale bibliotecas antes de ejecutar cualquier otra celda.

# Use pip to install imblearn
%pip install imblearn

Paso 2: Carga de los datos

El conjunto de datos de detección de fraudes contiene transacciones de tarjetas de crédito realizadas en septiembre de 2013 a lo largo de dos días por titulares de tarajetas de Europa. El conjunto de datos contiene solo características numéricas debido a una transformación de Análisis de Componentes Principales (PCA) que se aplicó a las características originales. PCA transformó todas las características excepto Time y Amount. Para proteger la confidencialidad, no podemos proporcionar las características originales ni más información general sobre los datos.

Estos detalles describen el conjunto de datos:

Las características V1, V2, V3, …, V28 son los componentes principales obtenidos con PCA
La característica Time contiene los segundos transcurridos entre cada transacción y la primera transacción del conjunto de datos
La característica Amount es el importe de la transacción. Puede usar esta característica para un aprendizaje que tenga en cuento los costes y que dependa de ejemplos
La columna Class es la variable de respuesta (destino). Tiene el valor 1 de fraude y, de lo contrario, 0.

Solo 492 transacciones, de 284 807 transacciones totales, son fraudulentas. El conjunto de datos está muy desequilibrado, porque la clase que es una minoría (fraudulento) solo representa aproximadamente el 0,172 % de los datos.

En esta tabla se muestra una vista previa de los datos de decreditcard.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	Amount	Clase
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"

Descarga del conjunto de datos y carga en un almacén de lago de datos

Defina estos parámetros para poder utilizar este cuaderno con diferentes conjuntos de datos:

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 descarga una versión disponible públicamente del conjunto de datos y, a continuación, la almacena en un almacén de un almacén de lago de Fabric.

Importante

Asegúrese de agregar un almacén de lago al cuaderno antes de ejecutarlo. De lo contrario, recibirá un error.

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

Configuración del seguimiento del experimento de MLflow

El proceso de seguimiento de experimentos guarda toda la información pertinente relacionada con el experimento para cada experimento que ejecute. A veces, no tiene ninguna manera de obtener mejores resultados al ejecutar un experimento específico. En esos casos, debe detener el experimento e intentar uno nuevo.

La experiencia de ciencia de datos de Synapse en Microsoft Fabric incluye una característica de registro automático. Esta característica reduce la cantidad de código necesario para registrar automáticamente los parámetros, las métricas y los elementos de un modelo de Machine Learning durante el entrenamiento. La característica amplía las funcionalidades de registro automático de MLflow. Tiene una integración profunda en la experiencia de ciencia de datos.

Con el registro automático, puede seguir y comparar fácilmente el rendimiento de diferentes modelos y experimentos sin necesidad de hacer seguimientos manuales. Para obtener más información, consulte Registro automático en Microsoft Fabric.

Para deshabilitar el registro automático de Microsoft Fabric en una sesión de cuaderno, llame a mlflow.autolog() y establezca disable=True.

# Set up MLflow for experiment tracking
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Lectura de datos sin procesar desde el lago de datos

Este código lee datos sin procesar de lakehouse:

df = (
    spark.read.format("csv")
    .option("header", "true")
    .option("inferSchema", True)
    .load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
    .cache()
)

Paso 3: Realiza un análisis exploratorio de los datos

En esta sección, primero explorará los datos sin procesar y las estadísticas de alto nivel. Después, para transformar los datos, convertirá las columnas en los tipos correctos y las convertirá de un DataFrame de Spark en un DataFrame de Pandas para facilitar la visualización. Por último, explorará y visualizará las distribuciones de clase en los datos.

Mostrar los datos sin procesar

Explore los datos sin procesar y vea las estadísticas de alto nivel con el comando display. Para obtener más información sobre la visualización de datos, consulte Visualización de cuadernos en Microsoft Fabric.
```
display(df)
```

Imprima información básica sobre el conjunto de datos:

# Print dataset basic information
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()

Transformar los datos

Convierta las columnas del conjunto de datos en los tipos correctos:

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)

Convierta el DataFrame de Spark en un DataFrame de Pandas para facilitar la visualización y el procesamiento:
```
df_pd = df.toPandas()
```

Exploración de la distribución de clases en el conjunto de datos

Muestre la distribución de clases en el conjunto de datos:
```
# 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')
```
El código devuelve esta distribución de clase del conjunto de datos: 99,83 % No Frauds y 0,17 % Frauds. Esta distribución de clases muestra que la mayoría de las transacciones no son fraudulentas. Por lo tanto, el preprocesamiento de datos es necesario antes del entrenamiento del modelo para evitar el sobreajuste.

Use un trazado para mostrar el desequilibrio de clases en el conjunto de datos mediante la visualización de la distribución de transacciones fraudulentas frente a no 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)

Se muestra el resumen de cinco números (puntuación mínima, primer cuartil, mediana, tercer cuartil y puntuación máxima) para el importe de la transacción, mediante trazados de cuadros:
```
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 los datos muy desequilibrados, es posible que los trazados de cuadros no muestren información precisa. También puede abordar el problema de desequilibrio de Class primero y, luego, crear los mismos trazados para obtener información más precisa.

Paso 4: Entrenamiento y evaluación de los modelos

Aquí entrenará un modelo LightGBM para clasificar transacciones fraudulentas. Entrene un modelo LightGBM tanto en el conjunto de datos desequilibrado como en el conjunto de datos equilibrado. A continuación, comparará el rendimiento de ambos modelos.

Preparación de conjuntos de datos de entrenamiento y prueba

Antes del entrenamiento, divida los datos en los conjuntos de datos de entrenamiento y prueba:

# 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]]

Aplicación de SMOTE al conjunto de datos de entrenamiento

La biblioteca imblearn usa el enfoque de técnica de sobremuestreo de minorías sintéticas (SMOTE) para abordar el problema de la clasificación desequilibrada. La clasificación desequilibrada se produce cuando hay demasiado pocos ejemplos disponibles de la clase que es minoría para que un modelo aprenda eficazmente el límite de decisión. SMOTE es el enfoque más utilizado para sintetizar nuevas muestras para la clase de minoría.

Aplique SMOTE solo al conjunto de datos de entrenamiento, en lugar de al conjunto de datos de prueba. Al puntuar el modelo con los datos de prueba, necesita una aproximación del rendimiento del modelo en datos no vistos en producción. Para conseguir una aproximación válida, los datos de prueba se basan en la distribución desequilibrada oroginal para representar los datos de producción de la manera más fiel posible.

# 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 obtener más información sobre SMOTE, vea la página de referencia de scikit-learn para el método SMOTE y la guía del usuario de scikit-learn sobre el sobremuestreo.

Entrenamiento de modelos de aprendizaje automático y ejecución de experimentos

Apache Spark en Microsoft Fabric permite el aprendizaje automático con macrodatos. Con Apache Spark, puede obtener información valiosa de grandes cantidades de datos estructurados, no estructurados y de movimiento rápido.

Tiene varias opciones para entrenar modelos de Machine Learning con Azure Spark en Microsoft Fabric: Apache Spark MLlib, SynapseML y otras bibliotecas de código abierto. Para más información, consulte Entrenamiento de modelos de aprendizaje automático en Microsoft Fabric.

Un experimento de aprendizaje automático sirve como unidad principal de organización y control para todas las ejecuciones de aprendizaje automático relacionadas. Una ejecución corresponde a una única ejecución del código del modelo. El seguimiento de experimentos de aprendizaje automático conlleva la administración de todos los experimentos y sus componentes, como parámetros, métricas, modelos y otros artefactos.

Para el seguimiento de experimentos, puede organizar todos los componentes necesarios de un experimento de aprendizaje automático específico. Asimismo, puede reproducir fácilmente los resultados pasados mediante experimentos guardados. Para obtener más información sobre los experimentos de aprendizaje automático, consulte Experimentos de aprendizaje automático en Microsoft Fabric.

Para realizar un seguimiento de más métricas, parámetros y archivos, establezca exclusive=False para actualizar la configuración de registro automático de MLflow:
```
mlflow.autolog(exclusive=False)
```

Entrene dos modelos con LightGBM. Un modelo controla el conjunto de datos desequilibrado y el otro controla el conjunto de datos equilibrado (a través de SMOTE). A continuación, compare el rendimiento de los dos 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 la importancia de las características para el entrenamiento

Determine la importancia de las características para el modelo que ha entrenado en el conjunto de datos 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 la importancia de las características para el modelo que ha entrenado en los datos equilibrados. SMOTE generó los datos 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 entrenar un modelo con el conjunto de datos desequilibrado, las características importantes tienen diferencias significativas en comparación con un modelo entrenado con el conjunto de datos equilibrado.

Evaluación de los modelos

Aquí evaluará los dos modelos entrenados:

model entrenado con datos sin procesar y desequilibrados
smote_model entrenado con datos equilibrados

Métricas del modelo de proceso

Defina una función prediction_to_spark que realice predicciones y convierta los resultados de la predicción en un Dataframe de Spark. Más adelante, podrá calcular las estadísticas del modelo en los resultados de predicción con 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 la función prediction_to_spark para realizar predicciones con los dos modelos, model y smote_model:

predictions = prediction_to_spark(model, test)
smote_predictions = prediction_to_spark(smote_model, test)
predictions.limit(10).toPandas()

Métricas de proceso para los dos 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)

Evaluación del rendimiento del modelo con una matriz de confusión

Una matriz de confusión muestra el número de

verdaderos positivos (VP)
verdaderos negativos (VN)
falsos positivos (FP)
falsos negativos (FN)

que un modelo genera cuando se puntua con datos de prueba. Para la clasificación binaria, el modelo devuelve una matriz de confusión 2x2. Para la clasificación multiclase, el modelo devuelve una matriz de confusión nxn, donde n es el número de clases.

Use una matriz de confusión para resumir los rendimientos de los modelos de aprendizaje automático entrenados en los datos de prueba:

# 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 la matriz de confusión para las predicciones de smote_model (entrenadas con datos 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 la matriz de confusión para las predicciones de model (entrenadas con datos sin procesar y desequilibrados):

with mlflow.start_run(run_id=raw_run.info.run_id):
    ax = plot(cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Evaluación del rendimiento del modelo con medidas AUC-ROC y AUPRC

La medida Área bajo la curva de la característica operativa del receptor (AUC-ROC) evalua el rendimiento de los clasificadores binarios. El gráfico AUC-ROC visualiza el equilibrio entre la tasa de verdaderos positivos (TPR) y la tasa de falsos positivos (FPR).

En algunos casos, es más adecuado evaluar el clasificador en función de la medida Área bajo la curva de precisión-coincidencias (AUPRC). La curva AUPRC combina estas tasas:

La precisión o valor predictivo positivo (PPV)
La recuperación o TPR

Para evaluar el rendimiento con las medidas AUC-ROC y AUPRC:

Defina una función que devuelva las medidas AUC-ROC y 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 las métricas AUC-ROC y AUPRC del modelo entrenado en datos 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 las métricas AUC-ROC y AUPRC del modelo entrenado en datos 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})

El modelo entrenado con los datos equilibrados devuelve valores AUC-ROC y AUPRC más altos en comparación con el modelo entrenado con los datos desequilibrados. En función de estas medidas, SMOTE parece ser una técnica eficaz para mejorar el rendimiento del modelo al trabajar con datos muy desequilibrados.

Como se muestra en la imagen siguiente, cualquier experimento se registra con su nombre respectivo. Puede realizar un seguimiento de los parámetros y las métricas de rendimiento del experimento en el área de trabajo.

En esta imagen se muestran las métricas de rendimiento del modelo entrenado con el conjunto de datos equilibrado (en la versión 2):

Puede seleccionar la versión 1 para ver las métricas del modelo entrenado en el conjunto de datos desequilibrado. Al comparar las métricas, AUROC es mayor para el modelo entrenado con el conjunto de datos equilibrado. Estos resultados indican que este modelo es mejor predecir correctamente 0 clases como 0 y predecir 1 clases como 1.

Paso 5: Registrar los modelos

Use MLflow para registrar los dos 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)

Paso 6: Guardar los resultados de la predicción

Microsoft Fabric permite a los usuarios poner en marcha modelos de Machine Learning con la función escalable PREDICT. Esta función admite la puntuación por lotes (o la inferencia por lotes) en cualquier motor de proceso.

Puede generar predicciones por lotes directamente desde el cuaderno de Microsoft Fabric o desde la página de elementos de un modelo. Para obtener más información sobre PREDICT, vea Puntuación de modelos con PREDICT en Microsoft Fabric.

Cargue el modelo de mejor rendimiento (versión 2) para la puntuación por lotes y genere los resultados de la predicción:

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)

Guardar las predicciones en el almacén de lago:

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

Compartir vía

Tutorial: creación, evaluación y puntuación de un modelo de detección de fraudes

Requisitos previos

Seguir en un cuaderno

Abra el cuaderno integrado

Importación del cuaderno desde GitHub

Paso 1: Instalación de bibliotecas personalizadas

Paso 2: Carga de los datos

Descarga del conjunto de datos y carga en un almacén de lago de datos

Configuración del seguimiento del experimento de MLflow

Lectura de datos sin procesar desde el lago de datos

Paso 3: Realiza un análisis exploratorio de los datos

Mostrar los datos sin procesar

Transformar los datos

Exploración de la distribución de clases en el conjunto de datos

Paso 4: Entrenamiento y evaluación de los modelos

Preparación de conjuntos de datos de entrenamiento y prueba

Aplicación de SMOTE al conjunto de datos de entrenamiento

Entrenamiento de modelos de aprendizaje automático y ejecución de experimentos

Determinar la importancia de las características para el entrenamiento

Evaluación de los modelos

Métricas del modelo de proceso

Evaluación del rendimiento del modelo con una matriz de confusión

Evaluación del rendimiento del modelo con medidas AUC-ROC y AUPRC

Paso 5: Registrar los modelos

Paso 6: Guardar los resultados de la predicción

Comentarios

Recursos adicionales

Compartir vía

Tutorial: creación, evaluación y puntuación de un modelo de detección de fraudes

Requisitos previos

Seguir en un cuaderno

Abra el cuaderno integrado

Importación del cuaderno desde GitHub

Paso 1: Instalación de bibliotecas personalizadas

Paso 2: Carga de los datos

Descarga del conjunto de datos y carga en un almacén de lago de datos

Configuración del seguimiento del experimento de MLflow

Lectura de datos sin procesar desde el lago de datos

Paso 3: Realiza un análisis exploratorio de los datos

Mostrar los datos sin procesar

Transformar los datos

Exploración de la distribución de clases en el conjunto de datos

Paso 4: Entrenamiento y evaluación de los modelos

Preparación de conjuntos de datos de entrenamiento y prueba

Aplicación de SMOTE al conjunto de datos de entrenamiento

Entrenamiento de modelos de aprendizaje automático y ejecución de experimentos

Determinar la importancia de las características para el entrenamiento

Evaluación de los modelos

Métricas del modelo de proceso

Evaluación del rendimiento del modelo con una matriz de confusión

Evaluación del rendimiento del modelo con medidas AUC-ROC y AUPRC

Paso 5: Registrar los modelos

Paso 6: Guardar los resultados de la predicción

Contenido relacionado

Comentarios

Recursos adicionales