Tutorial: Membuat, mengevaluasi, dan menilai model deteksi penipuan
Tutorial ini menyajikan contoh menyeluruh dari alur kerja Synapse Data Science, 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
- 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
- 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 bawah halaman beranda Anda untuk beralih ke Fabric.
- Jika perlu, buat Microsoft Fabric lakehouse sebagaimana dijelaskan di, Buat lakehouse di Microsoft Fabric,.
Ikuti di dalam buku catatan
Anda bisa memilih salah satu opsi ini untuk diikuti dalam buku catatan:
- 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 notebook 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 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 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 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 berbagai 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 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, kami tidak dapat menyediakan fitur asli atau informasi latar belakang lainnya tentang himpunan data.
Detail ini menjelaskan himpunan data:
- Fitur
V1
,V2
,V3
, ...,V28
adalah komponen utama yang diperoleh dengan PCA - Fitur
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 nilai1
untuk penipuan, dan0
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 Fabric lakehouse.
Penting
Pastikan untuk menambahkan lakehouse ke buku catatan sebelum Anda menjalankannya. 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.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 Synapse Data Science 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
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 perintah
display
. 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, prapemrosesan data diperlukan sebelum melatih 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 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)
Untuk informasi selengkapnya tentang SMOTE, lihat halaman referensi scikit-learn untuk metode SMOTE dan panduan pengguna scikit-learn tentang pengambilan sampel berlebihan sumber daya.
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. Suatu run sesuai dengan satu eksekusi kode model. Pembelajaran mesin pelacakan eksperimen 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 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")
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.
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
Tentukan fungsi
prediction_to_spark
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
Gunakan fungsi
prediction_to_spark
untuk melakukan prediksi dengan dua model,model
dansmote_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 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)
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 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 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 memungkinkan pengguna untuk mengoprasikan model pembelajaran mesin dengan fungsi 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")