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:

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.

1. Untuk membuka contoh buku catatan untuk tutorial ini, ikuti instruksi di Menyiapkan sistem Anda untuk tutorial ilmu data.

2. 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.

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

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.

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

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

2. Cetak beberapa informasi dasar tentang himpunan data:

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

Mengubah data

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

2. Konversikan Spark DataFrame ke DataFrame pandas untuk visualisasi dan pemrosesan yang lebih mudah:

   df_pd = df.toPandas()
   

Menjelajahi distribusi kelas dalam himpunan data

1. 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.

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

3. 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.

1. Untuk melacak lebih banyak metrik, parameter, dan file, atur exclusive=False untuk memperbarui konfigurasi autologging MLflow:

   mlflow.autolog(exclusive=False)
   

2. 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

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

2. 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

1. 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
   

2. Gunakan fungsi prediction_to_spark 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()
   

3. 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.

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

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

3. 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:

1. 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    
   

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

3. 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.

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

2. Simpan prediksi ke lakehouse:

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

Konten terkait

• Cara menggunakan notebook Microsoft Fabric
• Model pembelajaran mesin di Microsoft Fabric
• Melatih model pembelajaran mesin
• Eksperimen pembelajaran mesin di Microsoft Fabric