チュートリアル: 不正行為検出モデルを作成、評価、スコア付けする

このチュートリアルでは、Synapse Data Science ワークフローのエンド ツー エンドの例をMicrosoft Fabricで紹介します。 このシナリオでは、履歴データに対してトレーニングされたmachine learning アルゴリズムを使用して不正行為検出モデルを構築します。 その後、モデルを使用して、将来の不正なトランザクションを検出します。

このチュートリアルでは、次の手順について説明します。

前提 条件

• Microsoft Fabric サブスクリプションを取得します。 または、無料のMicrosoft Fabric試用版にサインアップします。

• Microsoft Fabric にサインインします。

• ホーム ページの左下にあるエクスペリエンス スイッチャーを使用して、Fabricに切り替えます。

  

• 必要に応じて、 Microsoft Fabric でレイクハウスを作成するで説明されているように、Microsoft Fabric のレイクハウスを作成します。

ノートブックで作業を進める

ノートブックで手順を追うには、次のいずれかの方法を選択してください。

• 組み込みのノートブックを開いて実行します。
• GitHubからノートブックをアップロードします。

組み込みのノートブックを開く

このチュートリアルには、不正検出 ノートブックのサンプルが付属しています。

1. このチュートリアルのサンプルノートブックを開くには、手順に従って、データサイエンスチュートリアル用にシステムを準備してください。

2. コードの実行を開始する前に、必ずレイクハウスをノートブックにアタッチしてください。

GitHubからノートブックをインポートする

このチュートリアルには、AIsample - Fraud Detection.ipynb ノートブックが付属しています。

• このチュートリアルの付属のノートブックを開くには、「データ サイエンス用にシステムを準備する」の手順に従って、ノートブックをワークスペースにインポート します。

• このページからコードをコピーして貼り付けたい場合は、新しいノートブック を作成することができます。

• コードの実行を開始する前に、必ずレイクハウスをノートブックにアタッチしてください。

手順 1: カスタム ライブラリをインストールする

machine learningモデル開発またはアドホック データ分析では、Apache Spark セッション用のカスタム ライブラリをすばやくインストールすることが必要になる場合があります。 ライブラリをインストールするには、2 つのオプションがあります。

• ノートブックのインライン インストール機能 (%pip または %conda) を使用して、現在のノートブックにのみライブラリをインストールします。
• または、Fabric環境を作成したり、パブリック ソースからライブラリをインストールしたり、カスタム ライブラリをアップロードしたりして、ワークスペース管理者がワークスペースの既定として環境をアタッチすることもできます。 環境内のすべてのライブラリは、ワークスペース内のすべてのノートブックと Spark ジョブ定義で使用できます。 環境の詳細については、「 Microsoft Fabric で環境を作成、構成、および使用する方法を参照してください。

このチュートリアルでは、%pip install を使用して imblearn ライブラリをノートブックにインストールします。

# Use pip to install imblearn
%pip install imblearn

手順 2: データを読み込む

不正検出データセットには、ヨーロッパのカード所有者が 2 日間にわたって行った 2013 年 9 月のクレジット カード トランザクションが含まれています。 データセットには、元のフィーチャに適用された主成分分析 (PCA) 変換が原因で、数値特徴のみが含まれます。 PCA は、Time と Amountを除くすべての機能を変換しました。 機密性を保護するために、データセットに関する元の機能またはより多くの背景情報は使用できません。

これらの詳細では、データセットについて説明します。

• V1、V2、V3、...、V28機能は、PCA で取得される主要なコンポーネントです。
• Time機能には、トランザクションとデータセット内の最初のトランザクションの間の経過時間 (秒) が含まれています。
• Amount 機能はトランザクション量です。 この機能は、例えばコスト重視の学習に使用できます。
• Class 列は応答 (ターゲット) 変数です。 不正アクセスの 1 値を持ち、それ以外の場合は 0 。

284,807 件のトランザクションのうち、不正なトランザクションは 492 件のみです。 少数派 (不正) クラスはデータの約 0.172% のみを占めるので、データセットは非常に不均衡です。

次の表に、creditcard.csv データのプレビューを示します。

データセットをダウンロードして lakehouse にアップロードする

さまざまなデータセットでこのノートブックを使用できるように、次のパラメーターを定義します。

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

このコードは、公開されているバージョンのデータセットをダウンロードし、Fabric 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.z13.web.core.windows.net/data/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.")

MLflow 実験の追跡を設定する

実験追跡プロセスでは、実行するすべての実験に関連するすべての実験関連の情報が保存されます。 場合によっては、特定の実験を実行するときに、より良い結果を得ることができない場合があります。 そのような場合は、実験を停止し、新しい実験を試してください。

Microsoft Fabricの Synapse Data Science エクスペリエンスには、自動ログ機能が含まれています。 この機能により、トレーニング中にmachine learning モデルのパラメーター、メトリック、項目を自動的にログに記録するために必要なコードの量が減ります。 この機能により、MLflow 自動ログ機能が拡張されます。 データ サイエンス エクスペリエンスに深い統合があります。

自動ログ記録を使用すると、手動で追跡しなくても、さまざまなモデルや実験のパフォーマンスを簡単に追跡および比較できます。 詳細については、「Microsoft Fabricを参照してください。

ノートブック セッションMicrosoft Fabric自動ログ記録を無効にするには、mlflow.autolog() を呼び出し、disable=Trueを設定します。

# Set up MLflow for experiment tracking
import mlflow

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

レイクハウスから生データを読み取る

このコードは、「レイクハウス」から生データを読み取ります。

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

手順 3: 探索的データ分析を実行する

このセクションでは、まず生データと高レベルの統計について説明します。 次に、データを変換するには、列を正しい型にキャストし、Spark DataFrame から pandas DataFrame に変換して視覚化を容易にします。 最後に、データ内のクラス分布を調べて視覚化します。

生データを表示する

1. display コマンドを使用して、生データを探索し、高レベルの統計情報を表示します。 データの視覚化の詳細については、「Microsoft Fabric のNotebook の視覚化」を参照してください。

   display(df)
   

2. データセットに関する基本的な情報を出力します。

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

データを変換する

1. データセット列を正しい型にキャストします。

   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. 視覚化と処理を容易にするために、Spark DataFrame を pandas DataFrame に変換します。

   df_pd = df.toPandas()
   

データセット内のクラス分布を調べる

1. データセットにクラス分布を表示します。

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

   このコードは、99.83% No Frauds と 0.17% Fraudsのデータセット クラス分布を返します。 このクラス分布は、ほとんどの取引が詐欺でないことを示しています。 そのため、オーバーフィットを回避するには、モデル トレーニングの前にデータの前処理が必要です。

2. 不正トランザクションと非侵害トランザクションの分布を表示して、データセット内のクラスの不均衡を表示するには、プロットを使用します。

   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. 取引金額の 5 つの数値の概要 (最小スコア、最初の四分位数、中央値、3 番目の四分位数、および最大スコア) をボックス プロットと共に表示します。

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

   非常に不均衡なデータの場合、箱ひげ図では正確な分析情報が表示されない場合があります。 ただし、最初に Class 不均衡の問題に対処してから、より正確な分析情報を得るための同じプロットを作成できます。

手順 4: モデルをトレーニングして評価する

この手順では、不正取引を分類する LightGBM モデルをトレーニングします。 不均衡なデータセットとバランスの取れたデータセットの両方で LightGBM モデルをトレーニングします。 次に、両方のモデルのパフォーマンスを比較します。

トレーニング データセットとテスト データセットを準備する

トレーニングの前に、データをトレーニング データセットとテスト データセットに分割します。

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

トレーニング データセットに SMOTE を適用する

imblearn ライブラリでは、合成少数派オーバーサンプリング手法 (SMOTE) アプローチを使用して、不均衡な分類の問題に対処します。 不均衡な分類は、少数派クラスの例が少なすぎる場合に発生し、モデルが意思決定境界を効果的に学習できるようにします。 SMOTE は、少数派クラスの新しいサンプルを合成するために最も広く使用されているアプローチです。

テスト データセットではなく、トレーニング データセットにのみ SMOTE を適用します。 テスト データを使用してモデルにスコアを付ける場合は、運用環境で見えないデータに対するモデルのパフォーマンスの近似値が必要です。 有効な近似値を得るために、テスト データは元の不均衡な分布に依存して、運用環境のデータを可能な限り厳密に表します。

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

machine learning モデルのトレーニングと実験の実行

Apache Spark Microsoft Fabricでは、ビッグ データを使用した機械学習が可能になります。 Apache Spark を使用すると、大量の構造化データ、非構造化データ、高速移動データから貴重な分析情報を得ることができます。

Microsoft Fabricの Apache Spark を使用して機械学習モデルをトレーニングするためのオプションとして、Apache Spark MLlib、SynapseML、その他のオープンソース ライブラリがいくつかあります。 詳細については、「 Microsoft Fabricを参照してください。

machine learning実験は、関連するすべてのmachine learning実行の組織と制御の主要な単位として機能します。 実行 は、モデル コードの 1 回の実行に対応します。 Machine learning experiment tracking には、パラメーター、メトリック、モデル、その他のartifactsなど、すべての実験とそのコンポーネントの管理が含まれます。

実験の追跡では、特定のmachine learning実験に必要なすべてのコンポーネントを整理できます。 また、保存された実験を使用して、過去の結果を簡単に再現できます。 機械学習実験に関する詳細は、Microsoft Fabric での機械学習実験を参照してください。

1. その他のメトリック、パラメーター、ファイルを追跡するには、MLflow の自動ログ構成を更新するように exclusive=False を設定します。

   mlflow.autolog(exclusive=False)
   

2. LightGBM を使用して 2 つのモデルをトレーニングします。 一方のモデルは不均衡なデータセットを処理し、もう 1 つのモデルは (SMOTE を介して) バランスの取れたデータセットを処理します。 次に、2 つのモデルのパフォーマンスを比較します。

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

トレーニングの特徴の重要度を決定する

1. 不均衡なデータセットでトレーニングしたモデルの特徴量の重要度を決定します。

   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. バランスの取れたデータでトレーニングしたモデルに対して、特徴量の重要度を決定します。 SMOTE によって、バランスの取れたデータが生成されました。

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

不均衡なデータセットを使用してモデルをトレーニングする場合、重要な特徴は、バランスの取れたデータセットでトレーニングされたモデルと比較して大きな違いを示します。

モデルを評価する

ここでは、トレーニング済みの 2 つのモデルを評価します。

• 未処理の不均衡データでトレーニングされた model
• smote_modelはバランスの取れたデータでトレーニングされています。

コンピューティング モデルのメトリック

1. 予測を行い、予測結果を Spark DataFrame に変換する prediction_to_spark 関数を定義します。 その後、 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. prediction_to_spark関数を使用して、modelとsmote_modelの 2 つのモデルで予測を行います。

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

3. 2 つのモデルのコンピューティング メトリック:

   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)
   

混同行列を使用してモデルのパフォーマンスを評価する

"混同行列" には、以下の数値が表示されます。

• 真陽性 (TP)
• 真陰性 (TN)
• 偽陽性 (FP)
• 偽陰性 (FN)

テストデータでスコア付けされるときにモデルが生成するもの 二項分類の場合、モデルは 2x2 混同行列を返します。 多クラス分類の場合、モデルは nxn 混同行列を返します。ここで、n はクラスの数です。

1. 混同行列を使用して、テスト データに対するトレーニング済みのmachine learning モデルのパフォーマンスを要約します。

   # 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. smote_model の予測の混同行列をプロットします (バランスの取れたデータに基づいてトレーニングされます)。

   # 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. model の予測の混同行列をプロットします (未加工の不均衡なデータに対してトレーニングされます)。

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

AUC-ROC と AUPRC 指標を使用してモデルのパフォーマンスを評価する

曲線レシーバ動作特性下面積(AUC-ROC)測定は、二項分類子のパフォーマンスを評価します。 AUC-ROC グラフでは、真陽性率 (TPR) と偽陽性率 (FPR) の間のトレードオフが視覚化されます。

場合によっては、Precision-Recall 曲線下面積 (AUPRC) 指標に基づいて分類器を評価する方が適切です。 AUPRC 曲線では、次のレートが結合されます。

• 精度、または正の予測値 (PPV)
• リコールまたは TPR

AUC-ROC および AUPRC 指標を用いてパフォーマンスを評価するには、

1. AUC-ROC および 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. 不均衡なデータに対してトレーニングしたモデルの AUC-ROC と AUPRC メトリックをログに記録します。

   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. バランスの取れたデータでトレーニングしたモデルの AUC-ROC と AUPRC メトリックをログに記録します。

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

バランスの取れたデータでトレーニングされたモデルは、不均衡なデータでトレーニングされたモデルと比較して高い AUC-ROC と AUPRC 値を返します。 これらの対策に基づいて、SMOTE は、非常に不均衡なデータを操作するときにモデルのパフォーマンスを向上させる効果的な手法のようです。

次の図に示すように、システムは各実験をそれぞれの名前でログに記録します。 ワークスペースで実験パラメーターとパフォーマンス メトリックを追跡できます。

次の図は、バランスの取れたデータセット ( バージョン 2) でトレーニングされたモデルのパフォーマンス メトリックを示しています。

バージョン 1 を選択すると、不均衡なデータセットでトレーニングされたモデルのメトリックが表示されます。 メトリックを比較すると、バランスの取れたデータセットでトレーニングされたモデルの AUROC の方が高いことがわかります。 これらの結果は、このモデルが 0として 0 クラスを正しく予測し、1 クラスを 1として予測する方が優れていることを示しています。

手順 5: モデルを登録する

MLflow を使用して 2 つのモデルを登録します。

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

手順 6: 予測結果を保存する

Microsoft Fabricユーザーは、PREDICT スケーラブルな関数を使用して機械学習モデルを運用化できます。 この関数は、任意のコンピューティング エンジンでのバッチ スコアリング (またはバッチ推論) をサポートします。

バッチ予測は、Microsoft Fabric ノートブックまたはモデルの項目ページから直接生成できます。 PREDICTの詳細については、「Microsoft FabricでのPREDICTを用いたモデルスコアリング」を確認してください。

1. バッチ スコアリングのためにパフォーマンスの高いモデル (バージョン 2) を読み込み、予測結果を生成します。

   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. 予測をレイクハウスに保存します。

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

関連コンテンツ

• Microsoft Fabric ノートブックを使用する方法
• Microsoft Fabric の機械学習モデル
• machine learning モデルのトレーニング
• Microsoft Fabric での機械学習実験