Självstudie: Skapa, utvärdera och poängsätta en modell för bedrägeriidentifiering

Den här handledningen presenterar ett exempel på ett arbetsflöde i Synapse Data Science från början till slut i Microsoft Fabric. Scenariot bygger en modell för identifiering av bedrägerier med maskininlärningsalgoritmer som tränats på historiska data. Den använder sedan modellen för att identifiera framtida bedrägliga transaktioner.

Den här handledningen täcker följande steg:

Förutsättningar

• Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri Microsoft Fabric-utvärderingsversion.

• Logga in på Microsoft Fabric.

• Använd upplevelseväxlaren längst ned till vänster på startsidan för att växla till Fabric.

  

• Om det behövs skapar du ett Microsoft Fabric Lakehouse enligt beskrivningen i Skapa ett sjöhus i Microsoft Fabric.

Följ med i en anteckningsbok

Du kan välja något av följande alternativ för att följa med i en anteckningsbok:

• Öppna och kör den inbyggda notebook-filen.
• Ladda upp din notebook från GitHub.

Öppna den inbyggda notebook-filen

Exempelnoteboken för bedrägeridetektion följer med den här handledningen.

1. Om du vill öppna exempelanteckningsboken för den här självstudien följer du anvisningarna i Förbereda systemet för självstudier för datavetenskap.

2. Se till att ansluta ett lakehouse till anteckningsboken innan du börjar köra kod.

Importera anteckningsboken från GitHub

Den AIsample – Fraud Detection.ipynb-filen medföljer denna handledning.

• Om du vill öppna den medföljande notebook-filen för den här självstudien följer du anvisningarna i Förbereda systemet för självstudier för datavetenskap importera anteckningsboken till din arbetsyta.

• Om du hellre kopierar och klistrar in koden från den här sidan kan du skapa en ny notebook-fil.

• Se till att anknyta ett lakehouse till din notebook innan du börjar köra kod.

Steg 1: Installera anpassade bibliotek

För utveckling av maskininlärningsmodeller eller ad hoc-dataanalys kan du snabbt behöva installera ett anpassat bibliotek för Apache Spark-sessionen. Du har två alternativ för att installera bibliotek.

• Använd inline installationsmöjligheter (%pip eller %conda) i din anteckningsbok för att installera ett bibliotek, endast i din aktuella anteckningsbok.
• Du kan också skapa en Infrastrukturmiljö, installera bibliotek från offentliga källor eller ladda upp anpassade bibliotek till den och sedan kan din arbetsyteadministratör koppla miljön som standard för arbetsytan. Alla bibliotek i miljön blir sedan tillgängliga för användning i alla notebook-filer och Spark-jobbdefinitioner på arbetsytan. Mer information om miljöer finns i skapa, konfigurera och använda en miljö i Microsoft Fabric.

I den här självstudien använder du %pip install för att installera imblearn-biblioteket i anteckningsboken.

# Use pip to install imblearn
%pip install imblearn

Steg 2: Läs in data

Datamängden för bedrägeriidentifiering innehåller kreditkortstransaktioner från september 2013 som europeiska kortinnehavare gjort under loppet av två dagar. Datamängden innehåller endast numeriska funktioner på grund av en PCA-transformering (Principal Component Analysis) som tillämpas på de ursprungliga funktionerna. PCA omvandlade alla funktioner förutom Time och Amount. För att skydda konfidentialiteten kan vi inte tillhandahålla de ursprungliga funktionerna eller mer bakgrundsinformation om datauppsättningen.

Den här informationen beskriver datamängden:

• Funktionerna V1, V2, V3, ..., V28 är huvudkomponenterna som hämtas med PCA
• Funktionen Time innehåller de förflutna sekunderna mellan en transaktion och den första transaktionen i datamängden
• Funktionen Amount är transaktionsbeloppet. Du kan använda den här funktionen för till exempel beroende, kostnadskänslig inlärning
• Kolumnen Class är variabeln svar (mål). Den har värdet 1 för bedrägeri och 0 annars

Endast 492 transaktioner, av totalt 284 807 transaktioner, är bedrägliga. Datamängden är mycket obalanserad eftersom minoritetsklassen (bedräglig) endast står för cirka 0,172% av data.

Den här tabellen visar en förhandsgranskning av creditcard.csv data:

Ladda ned datauppsättningen och ladda upp till lakehouse

Definiera dessa parametrar så att du kan använda den här notebook-filen med olika datauppsättningar:

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

Den här koden laddar ner en offentligt tillgänglig version av datamängden och lagrar den sedan i ett Fabric data lakehouse.

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

Konfigurera MLflow-experimentspårning

Experimentspårningsprocessen sparar all relevant experimentrelaterad information för varje experiment som du kör. Ibland kan du inte få bättre resultat när du kör ett specifikt experiment. I dessa fall bör du stoppa experimentet och prova ett nytt.

Synapse Data Science-upplevelsen i Microsoft Fabric innehåller en funktion för automatisk loggning. Den här funktionen minskar mängden kod som behövs för att automatiskt logga parametrar, mått och objekt i en maskininlärningsmodell under träningen. Funktionen utökar funktionerna för automatisk MLflow-loggning. Den har djup integrering i datavetenskapsupplevelsen.

Med automatisk loggning kan du enkelt spåra och jämföra prestanda för olika modeller och experiment, utan att behöva manuell spårning. Mer information finns i Automatisk loggning i Microsoft Fabric.

Om du vill inaktivera automatisk loggning av Microsoft Fabric i en notebook-session anropar du mlflow.autolog() och anger disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Läs rådata från "lakehouse"

Den här koden läser rådata från lakehouse:

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

Steg 3: Utföra undersökande dataanalys

I det här avsnittet utforskar du först rådata och statistik på hög nivå. Om du sedan vill omvandla data omvandlar du kolumnerna till rätt typer och konverterar dem från Spark DataFrame till en Pandas DataFrame för enklare visualisering. Slutligen utforskar och visualiserar du klassdistributionerna i data.

Visa rådata

1. Utforska rådata och visa statistik på hög nivå med kommandot display. Mer information om datavisualisering finns i Notebook-visualisering i Microsoft Fabric.

   display(df)
   

2. Skriv ut grundläggande information om datauppsättningen:

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

Transformera datan

1. Omvandla kolumnerna i datauppsättningen till rätt typer.

   import pyspark.sql.functions as F
   
   df_columns = df.columns
   df_columns.remove(TARGET_COL)
   
   # Ensure that TARGET_COL is the last column
   df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int"))
   
   if IS_SAMPLE:
       df = df.limit(SAMPLE_ROWS)
   

2. Konvertera Spark DataFrame till en Pandas DataFrame för enklare visualisering och bearbetning:

   df_pd = df.toPandas()
   

Utforska klassdistributionen i datauppsättningen

1. Visa klassfördelningen i datauppsättningen:

   # 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')
   

   Koden returnerar den här datamängdsklassfördelningen: 99,83% No Frauds och 0,17% Frauds. Den här klassfördelningen visar att de flesta transaktionerna är icke-bedrägliga. Därför krävs förbearbetning av data före modellträning för att undvika överanpassning.

2. Använd ett diagram för att visa klassobalansen i datamängden genom att visa fördelningen av bedrägliga kontra icke-bedrägliga transaktioner:

   import seaborn as sns
   import matplotlib.pyplot as plt
   
   colors = ["#0101DF", "#DF0101"]
   sns.countplot(x='Class', data=df_pd, palette=colors) 
   plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)
   

3. Visa femtalssammanfattningen (minsta poäng, första kvartilen, median, tredje kvartilen och högsta poäng) för transaktionsbeloppet, med rutor:

   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()
   

   För data med hög obalans kan det hända att lådritningar inte visar korrekta insikter. Du kan dock åtgärda problemet med Class obalans först och sedan skapa samma diagram för mer exakta insikter.

Steg 4: Träna och utvärdera modellerna

Här tränar du en LightGBM-modell för att klassificera bedrägeritransaktionerna. Du tränar en LightGBM-modell på både den obalanserade datamängden och den balanserade datamängden. Sedan jämför du prestandan för båda modellerna.

Förbereda tränings- och testdatauppsättningar

Innan träningen delar du upp data i tränings- och testdatauppsättningarna:

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

Tillämpa SMOTE på träningsdatauppsättningen

I imblearn-biblioteket används SMOTE-metoden (Synthetic Minority Oversampling Technique) för att lösa problemet med obalanserad klassificering. Obalanserad klassificering inträffar när för få exempel på minoritetsklassen är tillgängliga, för att en modell effektivt ska kunna lära sig beslutsgränsen. SMOTE är den mest använda metoden för att syntetisera nya exempel för minoritetsklassen.

Använd endast SMOTE på träningsdatauppsättningen i stället för testdatauppsättningen. När du bedömer modellen med testdata behöver du en uppskattning av modellens prestanda för osedda data i produktionen. För en giltig uppskattning förlitar sig testdata på den ursprungliga obalanserade fördelningen för att representera produktionsdata så nära som möjligt.

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

Mer information om SMOTE finns på referenssidan scikit-learn för SMOTE-metoden och användarhandboken för scikit-learn om att översampla resurser.

Träna maskininlärningsmodeller och köra experiment

Apache Spark i Microsoft Fabric möjliggör maskininlärning med stordata. Med Apache Spark kan du få värdefulla insikter från stora mängder strukturerade, ostrukturerade och snabba data.

Du har flera tillgängliga alternativ för att träna maskininlärningsmodeller med Apache Spark i Microsoft Fabric: Apache Spark MLlib, SynapseML och andra bibliotek med öppen källkod. Mer information finns i Träna maskininlärningsmodeller i Microsoft Fabric.

Ett maskininlärningsexperiment fungerar som den primära enheten för organisation och kontroll för alla relaterade maskininlärningskörningar. En körning motsvarar en enstaka exekvering av modellkoden. Maskininlärning experimentspårning omfattar hantering av alla experiment och deras komponenter, till exempel parametrar, mått, modeller och andra artefakter.

För experimentspårning kan du organisera alla nödvändiga komponenter i ett specifikt maskininlärningsexperiment. Dessutom kan du enkelt återskapa tidigare resultat med sparade experiment. Mer information om maskininlärningsexperiment finns i Maskininlärningsexperiment i Microsoft Fabric.

1. Om du vill spåra fler mått, parametrar och filer anger du exclusive=False för att uppdatera konfigurationen för automatisk MLflow-loggning:

   mlflow.autolog(exclusive=False)
   

2. Träna två modeller med LightGBM. Den ena modellen hanterar den obalanserade datamängden och den andra modellen hanterar den balanserade datamängden (via SMOTE). Jämför sedan prestandan för de två modellerna.

   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),
           ],
       )
   

Fastställa egenskapers viktighet för träning

1. Fastställa funktionsvikt för den modell som du har tränat på den obalanserade datamängden:

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

2. Fastställ variabelvikt för den modell som du har tränat på balanserad data. SMOTE genererade balanserade data:

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

För att träna en modell med den obalanserade datamängden har de viktiga funktionerna betydande skillnader jämfört med en modell som tränats med den balanserade datamängden.

Utvärdera modellerna

Här utvärderar du de två tränade modellerna:

• model tränade på rå, obalanserade data
• smote_model tränad på balanserade data

Beräkna modellmått

1. Definiera en prediction_to_spark funktion som utför förutsägelser och konverterar förutsägelseresultatet till en Spark DataFrame. Du kan sedan beräkna modellstatistik för förutsägelseresultatet med SynapseML-.

   from pyspark.sql.functions import col
   from pyspark.sql.types import IntegerType, DoubleType
   
   def prediction_to_spark(model, test):
       predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
       predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
       dataColumns = [TARGET_COL, "prediction"]
       predictions = (
           spark.createDataFrame(data=predictions, schema=dataColumns)
           .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
           .withColumn("prediction", col("prediction").cast(DoubleType()))
       )
   
       return predictions
   

2. Använd funktionen prediction_to_spark för att utföra förutsägelser med de två modellerna, model och smote_model:

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

3. Beräkningsmått för de två modellerna:

   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)
   

Utvärdera modellprestanda med en förvirringsmatris

En konfusionsmatris visar antalet

• sanna positiva (TP)
• sanna negativa (TN)
• falska positiva (FP)
• falska negativa resultat (FN)

som en modell producerar när den värderas med testuppgifter. För binär klassificering returnerar modellen en 2x2 förvirringsmatris. För klassificering med flera klasser returnerar modellen en nxn förvirringsmatris, där n är antalet klasser.

1. Använd en förvirringsmatris för att sammanfatta prestanda för de tränade maskininlärningsmodellerna på testdata:

   # Collect confusion matrix values
   cm = metrics.select("confusion_matrix").collect()[0][0].toArray()
   smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray()
   print(cm)
   

2. Rita konfusionsmatrisen för förutsägelserna av smote_model (tränat på balanserade data):

   # Plot the confusion matrix
   import seaborn as sns
   
   def plot(cm):
       """
       Plot the confusion matrix.
       """
       sns.set(rc={"figure.figsize": (5, 3.5)})
       ax = sns.heatmap(cm, annot=True, fmt=".20g")
       ax.set_title("Confusion Matrix")
       ax.set_xlabel("Predicted label")
       ax.set_ylabel("True label")
       return ax
   
   with mlflow.start_run(run_id=smote_run.info.run_id):
       ax = plot(smote_cm)
       mlflow.log_figure(ax.figure, "ConfusionMatrix.png")
   

3. Rita förvirringsmatrisen för förutsägelserna för model (tränad på rådata, obalanserade data):

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

Utvärdera modellprestanda med måtten AUC-ROC och AUPRC

Måttet Area Under the Curve Receiver Operating Characteristic (AUC-ROC) utvärderar prestanda för binära klassificerare. Diagrammet AUC-ROC visualiserar kompromissen mellan den sanna positiva frekvensen (TPR) och den falska positiva frekvensen (FPR).

I vissa fall är det mer lämpligt att utvärdera klassificeraren baserat på måttet Area Under Precision-Recall Curve (AUPRC). AUPRC-kurvan kombinerar dessa priser:

• Precisionen eller det positiva prediktiva värdet (PPV)
• Återkallandet, eller TPR

Så här utvärderar du prestanda med måtten AUC-ROC och AUPRC:

1. Definiera en funktion som returnerar måtten AUC-ROC och AUPRC:

   from pyspark.ml.evaluation import BinaryClassificationEvaluator
   
   def evaluate(predictions):
       """
       Evaluate the model by computing AUROC and AUPRC with the predictions.
       """
   
       # Initialize the binary evaluator
       evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL)
   
       _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions)
   
       # Calculate AUROC, baseline 0.5
       auroc = _evaluator("areaUnderROC")
       print(f"The AUROC is: {auroc:.4f}")
   
       # Calculate AUPRC, baseline positive rate (0.172% in the data)
       auprc = _evaluator("areaUnderPR")
       print(f"The AUPRC is: {auprc:.4f}")
   
       return auroc, auprc    
   

2. Logga måtten AUC-ROC och AUPRC för den modell som du har tränat på obalanserade data:

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

3. Logga måtten AUC-ROC och AUPRC för den modell som du har tränat på balanserade data:

   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})
   

Modellen som tränas på balanserade data returnerar högre AUC-ROC- och AUPRC-värden jämfört med modellen som tränas på obalanserade data. Baserat på dessa mått verkar SMOTE vara en effektiv teknik för att förbättra modellprestanda när du arbetar med mycket obalanserade data.

Som nästa bild visar loggas alla experiment med respektive namn. Du kan spåra experimentparametrar och prestandamått på din arbetsyta.

Den här bilden visar prestandamåtten för modellen som tränats på den balanserade datamängden (i version 2):

Du kan välja version 1 för att se måtten för modellen som tränats på den obalanserade datamängden. När du jämför måtten är AUROC högre för modellen som tränats med den balanserade datamängden. Dessa resultat visar att den här modellen är bättre på att korrekt förutsäga 0 klasser som 0och förutsäga 1 klasser som 1.

Steg 5: Registrera modellerna

Använd MLflow för att registrera de två modellerna:

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

Steg 6: Spara förutsägelseresultatet

Med Microsoft Fabric kan användare operationalisera maskininlärningsmodeller med den PREDICT skalbara funktionen. Den här funktionen stöder batchbedömning (eller batch-slutsatsdragning) i en beräkningsmotor.

Du kan generera batchförutsägelser direkt från Microsoft Fabric-anteckningsboken eller från en modells objektsida. För mer information om PREDICT, se Modellscoring med PREDICT i Microsoft Fabric.

1. Läs in modellen med bättre prestanda (version 2) för batchbedömning och generera förutsägelseresultatet:

   from synapse.ml.predict import MLFlowTransformer
   
   spark.conf.set("spark.synapse.ml.predict.enabled", "true")
   
   model = MLFlowTransformer(
       inputCols=feature_cols,
       outputCol="prediction",
       modelName=f"{EXPERIMENT_NAME}-lightgbm",
       modelVersion=2,
   )
   
   test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list())
   
   batch_predictions = model.transform(test_spark)
   

2. Spara förutsägelser till lakehouse:

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

Relaterat innehåll

• Hur man använder Microsoft Fabric-anteckningsböcker
• Maskininlärningsmodell i Microsoft Fabric
• Träna maskininlärningsmodeller
• Maskininlärningsexperiment i Microsoft Fabric