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. El escenario crea un modelo de detección de fraudes con algoritmos de aprendizaje automático entrenados en datos históricos. A continuación, usa el modelo para detectar transacciones fraudulentas futuras.
En este tutorial se describen estos pasos:
- Instalación de bibliotecas personalizadas
- Carga de los datos
- Descripción y procesamiento de los datos a través del análisis de datos exploratorios
- Uso de scikit-learn para entrenar un modelo de aprendizaje automático y realizar un seguimiento de los experimentos con las características de registro automático de MLflow y Fabric
- Guardar y registrar el modelo de Machine Learning que tiene el máximo rendimiento
- Carga del modelo de Machine Learning para la puntuación y para realizar predicciones
Prerrequisitos
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 la parte inferior izquierda de la página principal para cambiar a Fabric.
- Si es necesario, cree un almacén de lago de datos de Microsoft Fabric como se describe en Creación de un almacén de lago de datos en Microsoft Fabric.
Seguimiento en un cuaderno
Puede elegir una de estas opciones para seguir en un cuaderno:
- Abra y ejecute el cuaderno integrado.
- Cargue el cuaderno desde GitHub.
Abra el cuaderno integrado.
El cuaderno de ejemplo Detección de fraudes acompaña a este tutorial.
Para abrir el cuaderno de ejemplo de este tutorial, siga las instrucciones de Preparar el sistema para tutoriales de ciencia de datos.
Asegúrese de adjuntar un almacén de lago de datos al cuaderno antes de ejecutar el 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 Preparar su sistema para tutoriales de ciencia de datos para importar el cuaderno a su espacio de trabajo.
Si prefiere copiar y pegar el código de esta página, puede crear un cuaderno nuevo.
Asegúrese de adjuntar un almacén de lago de datos al cuaderno antes de empezar a ejecutar código.
Paso 1: Instalación de bibliotecas personalizadas
Para el desarrollo de modelos de Machine Learning o el 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 en línea (
%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, a continuación, el administrador del área de trabajo puede asociar el entorno como valor predeterminado para el área de trabajo. Todas las librerías del entorno estarán disponibles para su uso en cualquier cuaderno y en las definiciones de trabajos de Spark dentro del área de trabajo. Para obtener más información sobre los entornos, consulte crear, configurar y usar un entorno en Microsoft Fabric.
Para este tutorial, use %pip install para instalar la biblioteca imblearn en el cuaderno.
Nota
El kernel de PySpark se reinicia después de que se ejecute %pip install. Instale las bibliotecas necesarias antes de ejecutar cualquier otra celda.
# Use pip to install imblearn
%pip install imblearn
Paso 2: Cargar los datos
El conjunto de datos de detección de fraudes contiene transacciones de tarjetas de crédito, a partir de septiembre de 2013, que los titulares de tarjetas europeas han realizado durante dos días. El conjunto de datos solo contiene características numéricas debido a una transformación análisis de componentes principal (PCA) aplicada 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 el conjunto de datos.
Estos detalles describen el conjunto de datos:
- Las características de
V1,V2,V3, ...,V28son los componentes principales obtenidos con PCA. - La característica
Timecontiene los segundos transcurridos entre una transacción y la primera transacción del conjunto de datos. - La característica
Amountes la cantidad de transacción. Puede usar esta característica para el aprendizaje dependiente de ejemplos y sensible a los costos. - La columna
Classes la variable de respuesta (destino). Tiene el valor1en caso de fraude y0en cualquier otro caso.
Solo 492 transacciones, de 284.807 transacciones totales, son fraudulentas. El conjunto de datos está muy desequilibrado, ya que la clase minoritaria (fraudulenta) solo tiene en cuenta aproximadamente el 0,172 % de los datos.
En esta tabla se muestra una vista previa de los datos de creditcard.csv:
| Tiempo | 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 | Importe | 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 el almacén de lago de datos
Defina estos parámetros para poder usar 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 una instancia de Fabric Lakehouse.
Importante
Asegúrese de agregar un almacén de lago de datos al cuaderno antes de ejecutarlo. De lo contrario, se producirá 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 de experimentos 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 realizar un seguimiento y comparar fácilmente el rendimiento de diferentes modelos y experimentos, sin necesidad de realizar un seguimiento manual. Para más información, vea 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 almacén de lago de datos
Este código lee datos sin procesar del almacén de lago de datos:
df = (
spark.read.format("csv")
.option("header", "true")
.option("inferSchema", True)
.load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
.cache()
)
Paso 3: Realizar análisis de datos exploratorios
En esta sección, explorará primero los datos sin procesar y las estadísticas de alto nivel. Después, para transformar los datos, convierta las columnas a los tipos correctos y páselas del DataFrame de Spark a 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 más información sobre la visualización de datos, vea 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()
Transformación de 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
Muestra 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 de conjunto de datos: 99.83%
No Fraudsy 0.17%Frauds. Esta distribución de clases muestra que la mayoría de las transacciones no sonfraudulentes. 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 nofraudulentes:
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)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, con 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()En el caso de datos altamente desequilibrados, es posible que los diagramas de caja no muestren análisis precisos. Sin embargo, puede abordar primero el problema de desequilibrio
Classy, a continuación, crear los mismos gráficos para obtener información más precisa.
Paso 4: Entrenamiento y evaluación de los modelos
Aquí, entrenas un modelo LightGBM para clasificar las transacciones de fraude. Entrena un modelo LightGBM con el conjunto de datos desequilibrado y 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 la técnica de sobremuestreo de minorías sintéticas (SMOTE) para abordar el problema de la clasificación desequilibrada. La clasificación desequilibrada ocurre cuando hay muy pocos ejemplos de la clase minoritaria disponibles para que un modelo pueda aprender eficazmente el límite de decisión. SMOTE es el enfoque más utilizado para sintetizar nuevas muestras para la clase minoría.
Aplique SMOTE solo al conjunto de datos de entrenamiento, en lugar del 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 una aproximación válida, los datos de prueba dependen de la distribución desequilibrada original para representar los datos de producción lo más cerca 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 más información sobre SMOTE, vea los recursos Página de referencia de scikit-learn para el método SMOTE y Guía del usuario de scikit-learn sobre 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 disponibles para entrenar modelos de aprendizaje automático con Apache Spark en Microsoft Fabric: Apache Spark MLlib, SynapseML y otras bibliotecas de código abierto. Para obtener 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 sola ejecución de modelo de código. El aprendizaje automático el seguimiento de experimentos implica 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. Además, puede reproducir fácilmente los resultados pasados con 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 has entrenado en 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í, evalúas 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. Después, puede 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
Unamatriz de confusión muestra el número de
- verdaderos positivos (TP)
- verdaderos negativos (TN)
- falsos positivos (FP)
- falsos negativos (FN)
que un modelo produce cuando es puntuado 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 de AUC-ROC y AUPRC
La medida Área bajo la curva de la característica operativa del receptor (AUC-ROC) evalúa el rendimiento de los clasificadores binarios. El gráfico de AUC-ROC visualiza el equilibrio entre la tasa positiva verdadera (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:
- Precisión o valor predictivo positivo (PPV)
- Coincidencia, o TPR
Para evaluar el rendimiento con las medidas de AUC-ROC y AUPRC:
Defina una función que devuelva las medidas de 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, auprcRegistra las métricas de AUC-ROC y AUPRC para el modelo que entrenaste con datos desbalanceados.
with mlflow.start_run(run_id=raw_run.info.run_id): auroc, auprc = evaluate(predictions) mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc}) mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})Registre las métricas AUC-ROC y AUPRC del modelo que ha entrenado con 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 en los datos equilibrados devuelve valores de AUC-ROC y AUPRC más altos en comparación con el modelo entrenado en los datos desequilibrados. En función de estas medidas, SMOTE parece una técnica eficaz para mejorar el rendimiento del modelo al trabajar con datos altamente desequilibrados.
Como se muestra en la imagen siguiente, cualquier experimento se registra con su nombre respectivo. Puede realizar un seguimiento de los parámetros del experimento y las métricas de rendimiento en el área de trabajo.
En esta imagen se muestran las métricas de rendimiento del modelo entrenado en el conjunto de datos equilibrado (en versión 2):
Puede seleccionar 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 en predecir correctamente 0 clases como si fueran 0y en predecir 1 clases como si fueran 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 aprendizaje automático 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 más información sobre PREDICT, vea Puntuación del modelo 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)Guarde las predicciones en el almacén de lago de datos:
# Save the predictions to the lakehouse batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")