Руководство: Создание, анализ и оценка модели обнаружения мошенничества

В этом руководстве представлен полный пример рабочего процесса Обработки и анализа данных Synapse в Microsoft Fabric. Сценарий создает модель обнаружения мошенничества с алгоритмами машинного обучения, обученными на исторических данных. Затем она использует модель для обнаружения будущих мошеннических транзакций.

В этом руководстве рассматриваются следующие действия.

Необходимые условия

• Получите подписку Microsoft Fabric. Или зарегистрируйтесь для бесплатной пробной версии Microsoft Fabric.

• Войдите в Microsoft Fabric.

• Используйте переключатель интерфейса в левой нижней части домашней страницы, чтобы перейти на Fabric.

  

• При необходимости создайте озеро Microsoft Fabric, как описано в разделе Создание озера в Microsoft Fabric.

Следуйте инструкциям в записной книжке

Вы можете выбрать один из следующих вариантов для выполнения в записной книжке:

• Откройте и запустите встроенную записную книжку.
• Отправьте записную книжку из GitHub.

Открытие встроенной записной книжки

Примерный ноутбук для обнаружения мошенничества сопровождает это руководство.

1. Чтобы открыть пример записной книжки для этого руководства, следуйте инструкциям в Подготовке системы для учебников по обработке и анализу данных.

2. Перед началом выполнения кода обязательно подключить lakehouse к ноутбуку.

Импорт записной книжки из GitHub

AIsample — Обнаружение мошенничества.ipynb записная книжка сопровождает это руководство.

• Чтобы открыть сопровождающий ноутбук для этого руководства, следуйте инструкциям в для подготовки вашей системы к учебным руководствам по науке о данных, чтобы импортировать ноутбук в рабочую область.

• Если вы хотите скопировать и вставить код на этой странице, можно создать новую записную книжку.

• Не забудьте подключить lakehouse к блокноту перед началом выполнения кода.

Шаг 1. Установка пользовательских библиотек

Для разработки моделей машинного обучения или нерегламентированного анализа данных может потребоваться быстро установить пользовательскую библиотеку для сеанса Apache Spark. Существует два варианта установки библиотек.

• Используйте встроенные функции установки (%pip или %conda) ноутбука для установки библиотеки только в текущем ноутбуке.
• Кроме того, можно создать среду Fabric, установить библиотеки из общедоступных источников или отправить в нее пользовательские библиотеки, а затем администратор рабочей области может присоединить среду в качестве значения по умолчанию для рабочей области. Все библиотеки в среде будут доступны для использования в любых записных книжках и определениях заданий Spark в рабочей области. Подробнее о средах смотрите раздел "Создание, настройка и использование среды в Microsoft Fabric".

В этом руководстве используйте %pip install, чтобы установить библиотеку imblearn в вашем ноутбуке.

# Use pip to install imblearn
%pip install imblearn

Шаг 2. Загрузка данных

Набор данных по выявлению мошенничества содержит транзакции по кредитным картам за сентябрь 2013 года, совершенные европейскими держателями карт в течение двух дней. Набор данных содержит только числовые функции из-за преобразования основного анализа компонентов (PCA), примененного к исходным функциям. PCA преобразовал все функции, кроме Time и Amount. Чтобы защитить конфиденциальность, мы не можем предоставить исходные функции или дополнительные фоновые сведения о наборе данных.

Эти сведения описывают набор данных:

• Функции V1, V2, V3, ..., V28 являются основными компонентами, полученными с помощью PCA
• Функция Time содержит прошедшие секунды между транзакцией и первой транзакцией в наборе данных.
• Функция Amount — это сумма транзакции. Эту функцию можно использовать для зависимого от примеров, чувствительного к затратам обучения.
• Столбец Class — это переменная ответа (целевая переменная). Оно имеет значение 1 для мошенничества и 0 в противном случае

Только 492 транзакции, из 284 807 транзакций, являются мошенническими. Набор данных сильно несбалансирован, так как класс меньшинства (мошеннический) составляет только около 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.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.")

Настройка отслеживания экспериментов MLflow

Процесс отслеживания экспериментов сохраняет все соответствующие сведения, связанные с экспериментом, для каждого выполняемого эксперимента. Иногда вы не можете получить лучшие результаты при выполнении определенного эксперимента. В таких случаях следует остановить эксперимент и попробовать новый.

Интерфейс Обработки и анализа данных Synapse в Microsoft Fabric включает функцию автологирования. Эта функция уменьшает объем кода, необходимого для автоматического регистрации параметров, метрик и элементов модели машинного обучения во время обучения. Эта функция расширяет возможности автологирования 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. Выполнение анализа аналитических данных

В этом разделе вы сначала изучите необработанные данные и высокоуровневую статистику. Затем, чтобы преобразовать данные, приведите столбцы к правильным типам и преобразуйте их из DataFrame Spark в DataFrame pandas для упрощения визуализации. Наконец, вы изучаете и визуализируете распределения классов в данных.

Отображение необработанных данных

1. Изучите необработанные данные и просмотрите высокоуровневую статистику с помощью команды display. Дополнительные сведения о визуализации данных см. в статье Визуализация записной книжки в Microsoft Fabric.

   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 в кадр данных pandas для упрощения визуализации и обработки:

   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. Отображение сводки с пятью числами (минимальная оценка, первая квартиль, медиана, третий квартиль и максимальная оценка) для суммы транзакции с графиками полей:

   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)

Дополнительные сведения о SMOTE см. на справочной странице scikit-learn для метода SMOTE и в руководстве пользователя scikit-learn по ресурсам о сверхвыборке.

Обучение моделей машинного обучения и запуск экспериментов

Apache Spark в Microsoft Fabric позволяет машинному обучению с большими данными. С помощью Apache Spark вы можете получить ценные аналитические сведения из больших объемов структурированных, неструктурированных и быстро перемещаемых данных.

Вы можете обучать модели машинного обучения с помощью Apache Spark в Microsoft Fabric: Apache Spark MLlib, SynapseML и других библиотек с открытым кодом. Дополнительные сведения см. в статье Обучение моделей машинного обучения в Microsoft Fabric.

эксперимент машинного обучения служит основным элементом организации и управления всеми связанными запусками машинного обучения. запуск соответствует одному запуску кода модели. отслеживание экспериментов машинного обучения включает управление всеми экспериментами и их компонентами, такими как параметры, метрики, модели и другие артефакты.

Для отслеживания экспериментов можно упорядочить все необходимые компоненты определенного эксперимента машинного обучения. Кроме того, можно легко воспроизвести прошлые результаты с сохраненными экспериментами. Дополнительные сведения об экспериментах машинного обучения в Microsoft Fabric см. в разделе .

1. Чтобы отслеживать дополнительные метрики, параметры и файлы, задайте exclusive=False, чтобы обновить конфигурацию автологирования MLflow:

   mlflow.autolog(exclusive=False)
   

2. Обучение двух моделей с помощью LightGBM. Одна модель обрабатывает несбалансированный набор данных, а другая модель обрабатывает сбалансированный набор данных (через SMOTE). Затем сравните производительность двух моделей.

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

Для обучения модели с несбалансированным набором данных важные функции имеют значительные различия по сравнению с моделью, обученной с сбалансированным набором данных.

Оценка моделей

Здесь вы оцениваете две обученные модели:

• model обучается на необработанных, несбалансированных данных
• smote_model обученный на сбалансированных данных

Вычислить метрики модели

1. Определите функцию prediction_to_spark, которая выполняет прогнозы и преобразует результаты в DataFrame 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:

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

3. Метрики вычислений для двух моделей:

   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. Используйте матрицу путаницы для сводки производительности обученных моделей машинного обучения на тестовых данных:

   # 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 для регистрации двух моделей:

# 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см. в разделе Оценка модели с помощью PREDICT в Microsoft Fabric.

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. Сохраните прогнозы в lakehouse:

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

Связанное содержимое

• Использование записных книжек Microsoft Fabric
• модель машинного обучения в Microsoft Fabric
• Обучение моделей машинного обучения
• эксперименты машинного обучения в Microsoft Fabric