Tutorial: Membuat, mengevaluasi, dan menilai model deteksi penipuan

Artikel
01/23/2024

Tutorial ini menyajikan contoh end-to-end dari alur kerja Ilmu Data Synapse, di Microsoft Fabric. Skenario ini membangun model deteksi penipuan dengan algoritma pembelajaran mesin yang dilatih pada data historis. Kemudian menggunakan model untuk mendeteksi transaksi penipuan di masa mendatang.

Tutorial ini mencakup langkah-langkah berikut:

Menginstal pustaka kustom
Muat data
Memahami dan memproses data melalui analisis data eksploratif
Gunakan scikit-learn untuk melatih model pembelajaran mesin, dan melacak eksperimen dengan fitur MLflow dan Fabric Autologging
Menyimpan dan mendaftarkan model pembelajaran mesin yang memiliki performa tertinggi
Muat model pembelajaran mesin untuk penilaian dan untuk membuat prediksi

Prasyarat

Dapatkan langganan Microsoft Fabric. Atau, daftar untuk uji coba Microsoft Fabric gratis.
Masuk ke Microsoft Fabric.
Gunakan pengalih pengalaman di sisi kiri halaman beranda Anda untuk beralih ke pengalaman Ilmu Data Synapse.

Jika perlu, buat Microsoft Fabric lakehouse seperti yang dijelaskan dalam Membuat lakehouse di Microsoft Fabric.

Ikuti di buku catatan

Anda bisa memilih salah satu opsi ini untuk diikuti dalam buku catatan:

Buka dan jalankan buku catatan bawaan dalam pengalaman Ilmu Data
Unggah buku catatan Anda dari GitHub ke pengalaman Ilmu Data

Buka buku catatan bawaan

Contoh notebook deteksi Penipuan menyertai tutorial ini.

Untuk membuka buku catatan sampel bawaan tutorial dalam pengalaman Ilmu Data Synapse:

Buka halaman beranda Synapse Ilmu Data.
Pilih Gunakan sampel.
Pilih sampel yang sesuai:
- Dari tab Alur kerja end-to-end (Python) default, jika sampelnya adalah untuk tutorial Python.
- Dari tab Alur kerja end-to-end (R), jika sampelnya adalah untuk tutorial R.
- Dari tab Tutorial cepat, jika sampel adalah untuk tutorial cepat.
Lampirkan lakehouse ke buku catatan sebelum Anda mulai menjalankan kode.

Mengimpor notebook dari GitHub

Notebook AIsample - Fraud Detection.ipynb menyertai tutorial ini.

Untuk membuka buku catatan yang menyertai tutorial ini, ikuti instruksi dalam Menyiapkan sistem Anda untuk tutorial ilmu data, untuk mengimpor buku catatan ke ruang kerja Anda.

Jika Anda lebih suka menyalin dan menempelkan kode dari halaman ini, Anda bisa membuat buku catatan baru.

Pastikan untuk melampirkan lakehouse ke buku catatan sebelum Anda mulai menjalankan kode.

Langkah 1: Menginstal pustaka kustom

Untuk pengembangan model pembelajaran mesin atau analisis data ad-hoc, Anda mungkin perlu menginstal pustaka kustom dengan cepat untuk sesi Apache Spark Anda. Anda memiliki dua opsi untuk menginstal pustaka.

Gunakan kemampuan penginstalan sebaris (%pip atau %conda) buku catatan Anda untuk menginstal pustaka, hanya di buku catatan Anda saat ini.
Atau, Anda dapat membuat lingkungan Fabric, menginstal pustaka dari sumber publik atau mengunggah pustaka kustom ke dalamnya, dan kemudian admin ruang kerja Anda dapat melampirkan lingkungan sebagai default untuk ruang kerja. Semua pustaka di lingkungan kemudian akan tersedia untuk digunakan dalam notebook dan definisi pekerjaan Spark di ruang kerja. Untuk informasi selengkapnya tentang lingkungan, lihat membuat, mengonfigurasi, dan menggunakan lingkungan di Microsoft Fabric.

Untuk tutorial ini, gunakan %pip install untuk menginstal imblearn pustaka di buku catatan Anda.

Catatan

Kernel PySpark dimulai ulang setelah %pip install dijalankan. Instal pustaka yang diperlukan sebelum Anda menjalankan sel lain.

# Use pip to install imblearn
%pip install imblearn

Langkah 2: Muat data

Himpunan data deteksi penipuan berisi transaksi kartu kredit, mulai September 2013, yang dilakukan pemegang kartu Eropa selama dua hari. Himpunan data hanya berisi fitur numerik karena transformasi Analisis Komponen Utama (PCA) yang diterapkan ke fitur asli. PCA mengubah semua fitur kecuali dan TimeAmount. Untuk melindungi kerahasiaan, kami tidak dapat menyediakan fitur asli atau informasi latar belakang lainnya tentang himpunan data.

Detail ini menjelaskan himpunan data:

Fitur V1, , V3V2, ..., V28 adalah komponen utama yang diperoleh dengan PCA
Fitur ini Time berisi detik yang berlalu antara transaksi dan transaksi pertama dalam himpunan data
Fitur ini Amount adalah jumlah transaksi. Anda dapat menggunakan fitur ini untuk pembelajaran yang bergantung pada contoh dan sensitif terhadap biaya
Kolom Class adalah variabel respons (target). Ini memiliki nilai 1 untuk penipuan, dan 0 sebaliknya

Hanya 492 transaksi, dari total 284.807 transaksi, yang merupakan penipuan. Himpunan data sangat tidak seimbang, karena kelas minoritas (penipuan) hanya menyumbang sekitar 0,172% dari data.

Tabel ini memperlihatkan pratinjau data creditcard.csv :

Waktu	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	Jumlah	Kelas
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"

Mengunduh himpunan data dan mengunggah ke lakehouse

Tentukan parameter ini, sehingga Anda bisa menggunakan notebook ini dengan himpunan data yang berbeda:

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

Kode ini mengunduh versi himpunan data yang tersedia untuk umum, lalu menyimpannya di Fabric lakehouse.

Penting

Pastikan untuk menambahkan lakehouse ke buku catatan sebelum Anda menjalankannya. Jika tidak, Anda akan mendapatkan kesalahan.

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

Menyiapkan pelacakan eksperimen MLflow

Proses pelacakan eksperimen menyimpan semua informasi terkait eksperimen yang relevan untuk setiap eksperimen yang Anda jalankan. Terkadang, Anda tidak memiliki cara untuk mendapatkan hasil yang lebih baik ketika Anda menjalankan eksperimen tertentu. Dalam kasus tersebut, Anda harus menghentikan eksperimen dan mencoba yang baru.

Pengalaman Ilmu Data Synapse di Microsoft Fabric menyertakan fitur autologging. Fitur ini mengurangi jumlah kode yang diperlukan untuk mencatat parameter, metrik, dan item model pembelajaran mesin secara otomatis selama pelatihan. Fitur ini memperluas kemampuan autologging MLflow. Ini memiliki integrasi mendalam dalam pengalaman Ilmu Data.

Dengan autologging, Anda dapat dengan mudah melacak dan membandingkan performa model dan eksperimen yang berbeda, tanpa perlu pelacakan manual. Untuk informasi selengkapnya, lihat Autologging di Microsoft Fabric.

Untuk menonaktifkan autologging Microsoft Fabric dalam sesi notebook, panggil mlflow.autolog() dan atur disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Membaca data mentah dari lakehouse

Kode ini membaca data mentah dari lakehouse:

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

Langkah 3: Lakukan analisis data eksploratif

Di bagian ini, Anda terlebih dahulu menjelajahi data mentah dan statistik tingkat tinggi. Kemudian, untuk mengubah data, transmisikan kolom ke dalam jenis yang benar, dan konversikan dari Spark DataFrame menjadi Pandas DataFrame untuk visualisasi yang lebih mudah. Terakhir, Anda menjelajahi dan memvisualisasikan distribusi kelas dalam data.

Menampilkan data mentah

Jelajahi data mentah, dan lihat statistik tingkat tinggi, dengan display perintah . Untuk informasi selengkapnya tentang visualisasi data, lihat Visualisasi notebook di Microsoft Fabric.
```
display(df)
```

Cetak beberapa informasi dasar tentang himpunan data:

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

Mengubah data

Transmisikan kolom himpunan data ke dalam jenis yang benar:

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)

Konversikan Spark DataFrame ke DataFrame pandas untuk visualisasi dan pemrosesan yang lebih mudah:
```
df_pd = df.toPandas()
```

Menjelajahi distribusi kelas dalam himpunan data

Tampilkan distribusi kelas dalam himpunan data:
```
# 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')
```
Kode mengembalikan distribusi kelas himpunan data ini: 99,83% No Frauds dan 0,17% Frauds. Distribusi kelas ini menunjukkan bahwa sebagian besar transaksi tidak bersifat nonfraudulen. Oleh karena itu, praproses data diperlukan sebelum pelatihan model, untuk menghindari overfitting.

Gunakan plot untuk menunjukkan ketidakseimbangan kelas dalam himpunan data, dengan melihat distribusi transaksi penipuan versus transaksi nonfraudulen:

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)

Tampilkan ringkasan lima angka (skor minimum, kuartil pertama, median, kuartil ketiga, dan skor maksimum) untuk jumlah transaksi, dengan plot kotak:
```
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()
```
Untuk data yang sangat tidak seimbang, plot kotak mungkin tidak menampilkan wawasan yang akurat. Namun, Anda dapat mengatasi masalah ketidakseimbangan Class terlebih dahulu, lalu membuat plot yang sama untuk wawasan yang lebih akurat.

Langkah 4: Melatih dan mengevaluasi model

Di sini, Anda melatih model LightGBM untuk mengklasifikasikan transaksi penipuan. Anda melatih model LightGBM pada himpunan data yang tidak seimbang dan himpunan data yang seimbang. Kemudian, Anda membandingkan performa kedua model.

Menyiapkan himpunan data pelatihan dan pengujian

Sebelum pelatihan, pisahkan data menjadi himpunan data pelatihan dan pengujian:

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

Menerapkan SMOTE ke himpunan data pelatihan

Pustaka imblearn menggunakan pendekatan Synthetic Minority Oversampling Technique (SMOTE) untuk mengatasi masalah klasifikasi yang tidak seimbang. Klasifikasi yang tidak seimbang terjadi ketika terlalu sedikit contoh kelas minoritas tersedia, agar model mempelajari batas keputusan secara efektif. SMOTE adalah pendekatan yang paling banyak digunakan untuk mensintesis sampel baru untuk kelas minoritas.

Terapkan SMOTE hanya ke himpunan data pelatihan, bukan himpunan data pengujian. Saat Anda menilai model dengan data pengujian, Anda memerlukan perkiraan performa model pada data yang tidak jelas dalam produksi. Untuk perkiraan yang valid, data pengujian Anda bergantung pada distribusi asli yang tidak seimbang untuk mewakili data produksi sedekat mungkin.

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

Untuk informasi selengkapnya tentang SMOTE, lihat halaman referensi scikit-learn untuk metode SMOTE dan panduan pengguna scikit-learn tentang sumber daya pengambilan sampel berlebih.

Melatih model pembelajaran mesin dan menjalankan eksperimen

Apache Spark, di Microsoft Fabric, memungkinkan pembelajaran mesin dengan big data. Dengan Apache Spark, Anda bisa mendapatkan wawasan berharga dari sejumlah besar data terstruktur, tidak terstruktur, dan bergerak cepat.

Anda memiliki beberapa opsi yang tersedia untuk melatih model pembelajaran mesin dengan Apache Spark di Microsoft Fabric: Apache Spark MLlib, SynapseML, dan pustaka sumber terbuka lainnya. Untuk informasi selengkapnya, lihat Melatih model pembelajaran mesin di Microsoft Fabric.

Eksperimen pembelajaran mesin berfungsi sebagai unit utama organisasi dan kontrol untuk semua eksekusi pembelajaran mesin terkait. Eksekusi sesuai dengan satu eksekusi kode model. Pelacakan eksperimen pembelajaran mesin melibatkan manajemen semua eksperimen dan komponennya, seperti parameter, metrik, model, dan artefak lainnya.

Untuk pelacakan eksperimen, Anda dapat mengatur semua komponen yang diperlukan dari eksperimen pembelajaran mesin tertentu. Selain itu, Anda dapat dengan mudah mereproduksi hasil sebelumnya dengan eksperimen yang disimpan. Untuk informasi selengkapnya tentang eksperimen pembelajaran mesin, lihat Eksperimen pembelajaran mesin di Microsoft Fabric.

Untuk melacak lebih banyak metrik, parameter, dan file, atur exclusive=False untuk memperbarui konfigurasi autologging MLflow:
```
mlflow.autolog(exclusive=False)
```

Latih dua model dengan LightGBM. Satu model menangani himpunan data yang tidak seimbang, dan model lainnya menangani himpunan data seimbang (melalui SMOTE). Kemudian bandingkan performa kedua model.

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

Menentukan kepentingan fitur untuk pelatihan

Tentukan kepentingan fitur untuk model yang Anda latih pada himpunan data yang tidak seimbang:

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

Tentukan kepentingan fitur untuk model yang Anda latih pada data seimbang. SMOTE menghasilkan data seimbang:

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

Untuk melatih model dengan himpunan data yang tidak seimbang, fitur penting memiliki perbedaan yang signifikan jika dibandingkan dengan model yang dilatih dengan himpunan data yang seimbang.

Mengevaluasi model

Di sini, Anda mengevaluasi dua model terlatih:

model dilatih pada data mentah dan tidak seimbang
smote_model dilatih pada data seimbang

Metrik model komputasi

prediction_to_spark Tentukan fungsi yang melakukan prediksi, dan mengonversi hasil prediksi menjadi Spark DataFrame. Anda kemudian dapat menghitung statistik model pada hasil prediksi dengan 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

prediction_to_spark Gunakan fungsi untuk melakukan prediksi dengan dua model, model dan smote_model:

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

Komputasi metrik untuk dua model:

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)

Mengevaluasi performa model dengan matriks kebingungan

Matriks kebingungan menampilkan jumlah

positif benar (TP)
true negatives (TN)
positif palsu (FP)
false negatives (FN)

yang dihasilkan model saat dinilai dengan data pengujian. Untuk klasifikasi biner, model mengembalikan matriks 2x2 kebingungan. Untuk klasifikasi multikelas, model mengembalikan matriks kebingungan nxn , di mana n adalah jumlah kelas.

Gunakan matriks kebingungan untuk meringkas performa model pembelajaran mesin terlatih pada data pengujian:

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

Plot matriks smote_model kebingungan untuk prediksi (dilatih pada data seimbang):

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

Plot matriks model kebingungan untuk prediksi (dilatih pada data mentah dan tidak seimbang):

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

Mengevaluasi performa model dengan pengukuran AUC-ROC dan AUPRC

Ukuran Area di Bawah Karakteristik Operasi Penerima Kurva (AUC-ROC) menilai performa pengklasifikasi biner. Bagan AUC-ROC memvisualisasikan trade-off antara true positive rate (TPR) dan false positive rate (FPR).

Dalam beberapa kasus, lebih tepat untuk mengevaluasi pengklasifikasi Anda berdasarkan ukuran Area Di Bawah Kurva Presisi-Penarikan (AUPRC). Kurva AUPRC menggabungkan tarif ini:

Presisi, atau nilai prediktif positif (PPV)
Pengenalan, atau TPR

Untuk mengevaluasi performa dengan tindakan AUC-ROC dan AUPRC:

Tentukan fungsi yang mengembalikan pengukuran AUC-ROC dan 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

Catat metrik AUC-ROC dan AUPRC untuk model yang Anda latih pada data yang tidak seimbang:

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

Catat metrik AUC-ROC dan AUPRC untuk model yang Anda latih pada data seimbang:

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

Model yang dilatih pada data seimbang mengembalikan nilai AUC-ROC dan AUPRC yang lebih tinggi dibandingkan dengan model yang dilatih pada data yang tidak seimbang. Berdasarkan langkah-langkah ini, SMOTE tampaknya seperti teknik yang efektif untuk meningkatkan performa model saat bekerja dengan data yang sangat tidak seimbang.

Seperti yang ditunjukkan gambar berikutnya, eksperimen apa pun dicatat dengan nama masing-masing. Anda dapat melacak parameter eksperimen dan metrik performa di ruang kerja Anda.

Gambar ini menunjukkan metrik performa untuk model yang dilatih pada himpunan data seimbang (dalam Versi 2):

Anda dapat memilih Versi 1 untuk melihat metrik untuk model yang dilatih pada himpunan data yang tidak seimbang. Saat Anda membandingkan metrik, AUROC lebih tinggi untuk model yang dilatih dengan himpunan data seimbang. Hasil ini menunjukkan bahwa model ini lebih baik memprediksi 0 kelas dengan benar sebagai 0, dan memprediksi 1 kelas sebagai 1.

Langkah 5: Daftarkan model

Gunakan MLflow untuk mendaftarkan dua model:

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

Langkah 6: Simpan hasil prediksi

Microsoft Fabric memungkinkan pengguna untuk mengoprasikan model pembelajaran mesin dengan fungsi yang PREDICT dapat diskalakan. Fungsi ini mendukung penilaian batch (atau inferensi batch) di mesin komputasi apa pun.

Anda dapat membuat prediksi batch langsung dari buku catatan Microsoft Fabric atau dari halaman item model. Untuk informasi selengkapnya tentang PREDICT, lihat Penilaian model dengan PREDICT di Microsoft Fabric.

Muat model berkinerja lebih baik (Versi 2) untuk penilaian batch, dan hasilkan hasil prediksi:

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)

Simpan prediksi ke lakehouse:

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

Share via

Tutorial: Membuat, mengevaluasi, dan menilai model deteksi penipuan

Prasyarat

Ikuti di buku catatan

Buka buku catatan bawaan

Mengimpor notebook dari GitHub

Langkah 1: Menginstal pustaka kustom

Langkah 2: Muat data

Mengunduh himpunan data dan mengunggah ke lakehouse

Menyiapkan pelacakan eksperimen MLflow

Membaca data mentah dari lakehouse

Langkah 3: Lakukan analisis data eksploratif

Menampilkan data mentah

Mengubah data

Menjelajahi distribusi kelas dalam himpunan data

Langkah 4: Melatih dan mengevaluasi model

Menyiapkan himpunan data pelatihan dan pengujian

Menerapkan SMOTE ke himpunan data pelatihan

Melatih model pembelajaran mesin dan menjalankan eksperimen

Menentukan kepentingan fitur untuk pelatihan

Mengevaluasi model

Metrik model komputasi

Mengevaluasi performa model dengan matriks kebingungan

Mengevaluasi performa model dengan pengukuran AUC-ROC dan AUPRC

Langkah 5: Daftarkan model

Langkah 6: Simpan hasil prediksi

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan:

Share via

Tutorial: Membuat, mengevaluasi, dan menilai model deteksi penipuan

Prasyarat

Ikuti di buku catatan

Buka buku catatan bawaan

Mengimpor notebook dari GitHub

Langkah 1: Menginstal pustaka kustom

Langkah 2: Muat data

Mengunduh himpunan data dan mengunggah ke lakehouse

Menyiapkan pelacakan eksperimen MLflow

Membaca data mentah dari lakehouse

Langkah 3: Lakukan analisis data eksploratif

Menampilkan data mentah

Mengubah data

Menjelajahi distribusi kelas dalam himpunan data

Langkah 4: Melatih dan mengevaluasi model

Menyiapkan himpunan data pelatihan dan pengujian

Menerapkan SMOTE ke himpunan data pelatihan

Melatih model pembelajaran mesin dan menjalankan eksperimen

Menentukan kepentingan fitur untuk pelatihan

Mengevaluasi model

Metrik model komputasi

Mengevaluasi performa model dengan matriks kebingungan

Mengevaluasi performa model dengan pengukuran AUC-ROC dan AUPRC

Langkah 5: Daftarkan model

Langkah 6: Simpan hasil prediksi

Konten terkait

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan: