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

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

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

Необходимые компоненты

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

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

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

  

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

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

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

• Откройте и запустите встроенную записную книжку в интерфейсе Обработка и анализ данных
• Отправка записной книжки из GitHub в интерфейс Обработка и анализ данных

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

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

Чтобы открыть встроенную записную книжку учебника в интерфейсе Synapse Обработка и анализ данных:

1. Перейдите на домашнюю страницу Synapse Обработка и анализ данных.

2. Выберите " Использовать пример".

3. Выберите соответствующий пример:

   • На вкладке сквозных рабочих процессов (Python) по умолчанию, если пример предназначен для учебника по Python.
   • На вкладке сквозных рабочих процессов (R), если пример предназначен для руководства по R.
   • На вкладке "Краткие руководства", если пример предназначен для быстрого руководства.

4. Подключите 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% данных.

В этой таблице показана предварительная версия кредитных данных карта.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

Этот код загружает общедоступную версию набора данных, а затем сохраняет ее в Lakehouse Fabric.

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

Чтение необработанных данных из lakehouse

Этот код считывает необработанные данные из lakehouse:

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

Шаг 3. Выполнение анализа аналитических данных

В этом разделе вы сначала изучите необработанные данные и высокоуровневую статистику. Затем, чтобы преобразовать данные, приведение столбцов в правильные типы и преобразовать их из кадра данных Spark в кадр данных 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 использует подход искусственного меньшинства Oversampling Technique (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 функцию, которая выполняет прогнозы и преобразует результаты прогнозирования в кадр данных 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)
   

Оценка производительности модели с помощью матрицы путаницы

Матрица путаницы отображает число

• true positives (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).

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