Tutorial: Membuat, mengevaluasi, dan menilai model deteksi penipuan

Tutorial ini menyajikan contoh menyeluruh dari alur kerja Data Science. Skenario ini membangun model deteksi penipuan dengan menggunakan algoritma pembelajaran mesin yang dilatih berdasarkan data historis. Kemudian menggunakan model untuk mendeteksi transaksi penipuan di masa mendatang.

Tutorial ini mencakup langkah-langkah berikut:

Menginstal pustaka kustom
Memuat 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
Simpan dan daftarkan model machine learning yang memiliki performa tertinggi
Muat model machine learning untuk penilaian dan untuk membuat prediksi

Prasyarat

Dapatkan langganan Microsoft Fabric. Atau, daftar uji coba Microsoft Fabric gratis.
Masuk ke Microsoft Fabric.
Beralih ke Fabric dengan menggunakan pengalih pengalaman di sisi kiri bawah halaman beranda Anda.

Jika perlu, buat danau rumah Microsoft Fabric seperti yang diuraikan dalam Buat danau rumah dalam Microsoft Fabric.

Ikuti di dalam buku catatan

Untuk mengikuti di buku catatan, pilih salah satu opsi berikut:

Buka dan jalankan buku catatan bawaan.
Unggah buku catatan Anda dari GitHub.

Buka buku catatan bawaan

Contoh Pendeteksian penipuan notebook menyertai tutorial ini.

Untuk membuka contoh buku catatan untuk tutorial ini, ikuti instruksi di Menyiapkan sistem Anda untuk tutorial ilmu data.
Pastikan untuk menghubungkan lakehouse dengan notebook sebelum Anda mulai menjalankan kode.

Mengimpor buku catatan dari GitHub

Notebook AIsample - Fraud Detection.ipynb menyertai tutorial ini.

Untuk membuka buku catatan yang menyertai tutorial ini, ikuti instruksi di Menyiapkan sistem Anda untuk tutorial ilmu data 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 notebook sebelum Anda mulai menjalankan kode.

Langkah 1: Menginstal pustaka kustom

Untuk pengembangan model machine learning 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 secara langsung (%pip atau %conda) dari buku catatan Anda saat ini untuk menginstal pustaka, hanya di buku catatan tersebut.
Atau, Anda dapat membuat lingkungan Fabric, menginstal pustaka dari sumber publik atau mengunggah pustaka kustom ke lingkungan tersebut, lalu admin ruang kerja Anda dapat melampirkan lingkungan sebagai default untuk ruang kerja. Semua pustaka di lingkungan tersedia untuk digunakan dalam notebook apa pun dan definisi pekerjaan Spark di ruang kerja. Untuk informasi selengkapnya tentang lingkungan, lihat buat, konfigurasikan, dan gunakan lingkungan di Microsoft Fabric.

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

Nota

Kernel PySpark dimulai ulang setelah %pip install selesai berjalan. 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 untuk Time dan Amount. Untuk melindungi kerahasiaan, fitur asli atau informasi latar belakang lainnya tentang himpunan data tidak tersedia.

Detail ini menjelaskan himpunan data:

Fitur V1, , V2V3, ..., V28 adalah komponen utama yang diperoleh dengan PCA.
Fitur ini Time berisi detik yang berlalu antara transaksi dan transaksi pertama dalam himpunan data.
Fitur 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 keseluruhan 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 lakehouse Fabric.

Penting

Sebelum menjalankan buku catatan, tambahkan lakehouse. Jika tidak, Anda akan mengalami 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.z13.web.core.windows.net/data/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        raise FileNotFoundError("Default lakehouse not found, please add a lakehouse and restart the session.")
    os.makedirs(download_path, exist_ok=True)
    if not os.path.exists(f"{download_path}/{fname}"):
        r = requests.get(f"{remote_url}/{fname}", timeout=30)
        with open(f"{download_path}/{fname}", "wb") as f:
            f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

Menyiapkan pelacakan eksperimen MLflow

Proses pelacakan eksperimen menyimpan semua informasi terkait eksperimen yang relevan untuk setiap eksperimen yang Anda jalankan. Terkadang, Anda tidak dapat memperoleh hasil yang lebih baik saat menjalankan eksperimen tertentu. Dalam kasus tersebut, hentikan eksperimen dan coba yang baru.

Data Science menyertakan fitur autologing. Fitur ini mengurangi jumlah kode yang diperlukan untuk mencatat parameter, metrik, dan item model machine learning secara otomatis selama pelatihan. Fitur ini memperluas kemampuan autologging MLflow. Ia memiliki integrasi mendalam dalam beban kerja Data Science.

Dengan menggunakan 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 Microsoft Fabric autologging dalam sesi buku catatan, 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

Baca 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 menggunakan 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

Ubah kolom data ke dalam tipe 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

Dalam langkah ini, 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 kinerja model pada data yang belum terlihat 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)

Melatih model machine learning dan menjalankan eksperimen

Apache Spark, dalam Microsoft Fabric, memungkinkan pembelajaran mesin dengan big data. Dengan menggunakan 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 model pembelajaran mesin Train di Microsoft Fabric.

Eksperimen machine learning berfungsi sebagai unit utama organisasi dan kontrol untuk semua eksekusi machine learning terkait. Suatu run sesuai dengan satu eksekusi kode model. Machine learning pelacakan eksperimen melibatkan manajemen semua eksperimen dan komponennya, seperti parameter, metrik, model, dan artifacts lainnya.

Untuk pelacakan eksperimen, Anda dapat mengatur semua komponen yang diperlukan dari eksperimen machine learning 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 di atas data yang 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")

Saat Anda melatih model dengan himpunan data yang tidak seimbang, fitur penting menunjukkan perbedaan yang signifikan dibandingkan dengan model yang dilatih dengan himpunan data seimbang.

Evaluasi 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 membuat prediksi dan mengonversi hasil prediksi menjadi Spark DataFrame. Anda kemudian dapat menghitung statistik model pada hasil prediksi dengan menggunakan 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 membuat 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 menunjukkan jumlah

positif sejati (TP)
negatif benar (NB)
positif palsu (FP)
negatif palsu (FN)

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

Gunakan matriks kebingungan untuk meringkas performa model machine learning 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)

Buat matriks kebingungan untuk prediksi smote_model (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")

Gambarkan matriks kebingungan untuk prediksi model yang 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 langkah-langkah AUC-ROC dan AUPRC

Ukuran Area Di Bawah Karakteristik Operasi Penerima Kurva (AUC-ROC) menilai performa pengklasifikasi biner. Bagan AUC-ROC memvisualisasikan kompromi antara tingkat positif benar (TPR) dan tingkat positif salah (FPR).

Dalam beberapa kasus, lebih tepat untuk mengevaluasi pengklasifikasi Anda berdasarkan metrik Area di Bawah Kurva Precision-Recall (AUPRC). Kurva AUPRC menggabungkan tarif ini:

Presisi, atau nilai prediktif positif (PPV)
Penarikan kembali, atau TPR

Untuk mengevaluasi performa dengan langkah-langkah 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 telah Anda latih pada data yang 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 oleh gambar berikut, sistem mencatat setiap eksperimen dengan nama masing-masing. Anda dapat melacak parameter eksperimen dan metrik performa di ruang kerja Anda.

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

Pilih Versi 1 untuk melihat metrik untuk model yang dilatih pada himpunan data yang tidak seimbang. Saat membandingkan metrik, Anda melihat bahwa AUROC lebih tinggi untuk model yang dilatih dengan dataset yang seimbang. Hasil ini menunjukkan bahwa model ini lebih baik memprediksi kelas 0 dengan benar sebagai 0, dan memprediksi kelas 1 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 pengguna dapat mengoprasikan model pembelajaran mesin dengan menggunakan fungsi PREDICT yang 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")

Cara menggunakan notebook Microsoft Fabric
Model pembelajaran mesin dalam Microsoft Fabric
`Melatih model pembelajaran mesin`
eksperimen pembelajaran mesin dalam Microsoft Fabric

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-04-07