Tutorial: creación, evaluación y puntuación de un modelo de detección de fraudes
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 (
%pipo%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, …,V28son los componentes principales obtenidos con PCA - La característica
Timecontiene los segundos transcurridos entre cada transacción y la primera transacción del conjunto de datos - La característica
Amountes 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
Classes la variable de respuesta (destino). Tiene el valor1de 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 Fraudsy 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
Classprimero 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=Falsepara 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:
modelentrenado con datos sin procesar y desequilibradossmote_modelentrenado con datos equilibrados
Métricas del modelo de proceso
Defina una función
prediction_to_sparkque 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 predictionsUse la función
prediction_to_sparkpara realizar predicciones con los dos modelos,modelysmote_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, auprcRegistre 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")