자습서: 사기 감지 모델 만들기, 평가 및 점수 매기기

  • 아티클

이 자습서에서는 Microsoft Fabric에서 Synapse 데이터 과학 워크플로의 엔드 투 엔드 예제를 제공합니다. 이 시나리오는 기록 데이터에 대해 학습된 기계 학습 알고리즘을 사용하여 사기 감지 모델을 빌드합니다. 그런 다음 모델을 사용하여 향후 사기성 트랜잭션을 검색합니다.

이 자습서에서는 다음 단계를 설명합니다.

  • 사용자 지정 라이브러리 설치
  • 데이터 로드
  • 예비 데이터 분석을 통해 데이터 이해 및 처리
  • scikit-learn을 사용하여 기계 학습 모델을 학습하고 MLflow 및 패브릭 자동 로깅 기능을 사용하여 실험을 추적합니다.
  • 성능이 가장 높은 기계 학습 모델 저장 및 등록
  • 점수 매기기 및 예측을 위한 기계 학습 모델 로드

필수 조건

  • Microsoft Fabric 구독을 가져옵니다. 또는 무료 Microsoft Fabric 평가판에 등록합니다.

  • Microsoft Fabric에 로그인합니다.

  • 홈페이지 왼쪽의 환경 전환기를 사용하여 Synapse 데이터 과학 환경으로 전환합니다.

    Screenshot of the experience switcher menu, showing where to select Data Science.

전자 필기장에서 팔로우

다음 옵션 중 하나를 선택하여 전자 필기장에서 따를 수 있습니다.

  • 데이터 과학 환경에서 기본 제공 Notebook 열기 및 실행
  • GitHub에서 데이터 과학 환경으로 Notebook 업로드

기본 제공 Notebook 열기

샘플 사기 감지 Notebook은 이 자습서와 함께 제공됩니다.

Synapse 데이터 과학 환경에서 자습서의 기본 제공 샘플 Notebook을 열려면 다음을 수행합니다.

  1. Synapse 데이터 과학 홈페이지로 이동합니다.

  2. 샘플 사용을 선택합니다.

  3. 해당 샘플을 선택합니다.

    • 기본 Python(엔드 투 엔드 워크플로) 탭에서 샘플이 Python 자습서용인 경우
    • R(엔드 투 엔드 워크플로) 탭에서 샘플이 R 자습서용인 경우
    • 빠른 자습서 탭에서 샘플이 빠른 자습서용인 경우

  4. 코드 실행을 시작하기 전에 Lakehouse를 Notebook 에 연결합니다.

GitHub에서 Notebook 가져오기

AIsample - Fraud Detection.ipynb Notebook은 이 자습서와 함께 제공됩니다.

이 자습서에 대해 함께 제공되는 Notebook을 열려면 데이터 과학 자습서를 위해 시스템 준비 자습서의 지침에 따라 Notebook을 작업 영역으로 가져옵니다.

이 페이지에서 코드를 복사하여 붙여 넣으면 새 Notebook을 만들 수 있습니다.

코드 실행을 시작하기 전에 Lakehouse를 Notebook에 연결해야 합니다.

1단계: 사용자 지정 라이브러리 설치

기계 학습 모델 개발 또는 임시 데이터 분석의 경우 Apache Spark 세션에 대한 사용자 지정 라이브러리를 신속하게 설치해야 할 수 있습니다. 라이브러리를 설치하는 두 가지 옵션이 있습니다.

  • 현재 Notebook에만 라이브러리를 설치하려면 Notebook의 인라인 설치 기능(%pip 또는 %conda)을 사용합니다.
  • 또는 패브릭 환경을 만들거나, 공용 원본에서 라이브러리를 설치하거나, 사용자 지정 라이브러리를 업로드한 다음, 작업 영역 관리자가 작업 영역의 기본값으로 환경을 연결할 수 있습니다. 그러면 환경의 모든 라이브러리를 작업 영역의 모든 Notebook 및 Spark 작업 정의에서 사용할 수 있게 됩니다. 환경에 대한 자세한 내용은 Microsoft Fabric에서 환경 만들기, 구성 및 사용을 참조 하세요.

이 자습서에서는 Notebook에 라이브러리를 imblearn 설치하는 데 사용합니다%pip install.

참고 항목

실행 후 %pip install PySpark 커널이 다시 시작됩니다. 다른 셀을 실행하기 전에 필요한 라이브러리를 설치합니다.

# Use pip to install imblearn
%pip install imblearn

2단계: 데이터 로드

사기 감지 데이터 세트에는 2013년 9월부터 유럽 카드 보유자가 이틀 동안 수행한 신용 카드 거래가 포함됩니다. 데이터 세트에는 원래 기능에 적용된 PCA(보안 주체 분석) 변환으로 인해 숫자 기능만 포함됩니다. PCA는 다음을 Time 제외한 모든 기능을 변환했습니다 Amount. 기밀성을 보호하기 위해 원래 기능 또는 데이터 세트에 대한 자세한 배경 정보를 제공할 수 없습니다.

이러한 세부 정보는 데이터 세트를 설명합니다.

  • V1, V2, V3..., V28 기능은 PCA를 사용하여 얻은 주요 구성 요소입니다.
  • 이 기능에는 Time 데이터 세트의 트랜잭션과 첫 번째 트랜잭션 사이의 경과된 초가 포함됩니다.
  • 이 Amount 기능은 트랜잭션 금액입니다. 이 기능은 예제에 종속된 비용에 민감한 학습에 사용할 수 있습니다.
  • 열은 Class 응답(대상) 변수입니다. 사기에 대한 가치가 1 있으며 0 , 그렇지 않으면

총 284,807개 트랜잭션 중 492개 트랜잭션만이 사기입니다. 소수(사기성) 클래스는 데이터의 약 0.172%만 차지하므로 데이터 세트는 불균형이 매우 깁니다.

이 표에는 크레딧카드.csv 데이터의 미리 보기가 표시됩니다.

Time 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 수량 클래스
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"

데이터 세트를 다운로드하고 레이크하우스에 업로드

다른 데이터 세트와 함께 이 Notebook을 사용할 수 있도록 이러한 매개 변수를 정의합니다.

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에 저장합니다.

Important

레이크하우스를 실행하기 전에 Notebook에 추가해야 합니다. 그렇지 않으면 오류가 발생합니다.

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 실험 추적 설정

실험 추적 프로세스는 실행하는 모든 실험에 대한 모든 관련 실험 관련 정보를 저장합니다. 경우에 따라 특정 실험을 실행할 때 더 나은 결과를 얻을 수 있는 방법이 없습니다. 이러한 경우 실험을 중지하고 새 실험을 시도해야 합니다.

Microsoft Fabric의 Synapse 데이터 과학 환경에는 자동 로깅 기능이 포함되어 있습니다. 이 기능은 학습 중에 기계 학습 모델의 매개 변수, 메트릭 및 항목을 자동으로 기록하는 데 필요한 코드 양을 줄입니다. 이 기능은 MLflow 자동 로깅 기능을 확장합니다. 데이터 과학 환경에 깊은 통합이 있습니다.

자동 로깅을 사용하면 수동 추적 없이도 다양한 모델 및 실험의 성능을 쉽게 추적하고 비교할 수 있습니다. 자세한 내용은 Microsoft Fabric의 자동 로깅을 참조 하세요.

Notebook 세션에서 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에서 원시 데이터를 읽습니다.

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%와 0.17%Frauds의 No 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개 숫자 요약(최소 점수, 첫 번째 사분위수, 중앙값, 세 번째 사분위수 및 최대 점수)을 표시합니다.

    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 에 대한 자세한 내용은 SMOTE 메서드 에 대한 scikit-learn 참조 페이지와 리소스 과다 샘플링에 대한 scikit-learn 사용자 가이드를 참조하세요.

기계 학습 모델 학습 및 실험 실행

Microsoft Fabric의 Apache Spark를 사용하면 빅 데이터로 기계 학습을 수행할 수 있습니다. Apache Spark를 사용하면 많은 양의 구조화되고, 구조화되지 않고, 빠르게 이동하는 데이터에서 중요한 인사이트를 얻을 수 있습니다.

Microsoft Fabric에서 Apache Spark를 사용하여 기계 학습 모델을 학습하는 데 사용할 수 있는 몇 가지 옵션(Apache Spark MLlib, SynapseML 및 기타 오픈 소스 라이브러리)이 있습니다. 자세한 내용은 Microsoft Fabric에서 기계 학습 모델 학습을 참조 하세요.

기계 학습 실험은 모든 관련 기계 학습 실행에 대한 조직 및 제어의 기본 단위 역할을 합니다. 실행은 모델 코드의 단일 실행에 해당합니다. 기계 학습 실험 추적 에는 매개 변수, 메트릭, 모델 및 기타 아티팩트와 같은 모든 실험 및 해당 구성 요소의 관리가 포함됩니다.

실험 추적을 위해 특정 기계 학습 실험의 모든 필수 구성 요소를 구성할 수 있습니다. 또한 저장된 실험을 사용하여 과거 결과를 쉽게 재현할 수 있습니다. 기계 학습 실험에 대한 자세한 내용은 Microsoft Fabric의 Machine Learning 실험을 참조하세요.

  1. 더 많은 메트릭, 매개 변수 및 파일을 추적하려면 MLflow 자동 로깅 구성을 업데이트하도록 설정합니다 exclusive=False .

    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 DataFrame으로 변환하는 함수를 정의합니다. 그런 다음 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 사용하여 두 모델을 사용하여 예측을 수행하고 다음 modelsmote_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(true negatives)
  • FP(가양성)
  • FN(false negatives)

테스트 데이터로 채점할 때 모델이 생성하는 입니다. 이진 분류의 경우 모델은 혼동 행렬을 2x2 반환합니다. 다중 클래스 분류의 경우 모델은 클래스 수가 있는 n 혼동 행렬을 반환 nxn 합니다.

  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는 불균형이 높은 데이터로 작업할 때 모델 성능을 향상시키는 효과적인 기술처럼 보입니다.

다음 이미지에서와 같이 모든 실험은 해당 이름으로 기록됩니다. 작업 영역에서 실험 매개 변수 및 성능 메트릭을 추적할 수 있습니다.

Screenshot of the tracked experiment.

이 이미지는 균형 잡힌 데이터 세트(버전 2)에서 학습된 모델의 성능 메트릭을 보여줍니다.

Screenshot of logged model performance metrics and model parameters.

버전 1을 선택하여 불균형 데이터 세트에서 학습된 모델의 메트릭을 볼 수 있습니다. 메트릭을 비교할 때 분산된 데이터 세트로 학습된 모델에 대해 AUROC가 더 높습니다. 이러한 결과는 이 모델이 클래스를 올바르게 예측하고 클래스를 0 다음과 같이 01예측하는 데 더 낫다는 것을 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 Notebook 또는 모델의 항목 페이지에서 직접 일괄 처리 예측을 생성할 수 있습니다. 자세한 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")

관련 콘텐츠