Öğretici: Sahtekarlık algılama modeli oluşturma, değerlendirme ve puanlama

  • Makale

Bu öğretici, Microsoft Fabric'te Synapse Veri Bilimi iş akışının uçtan uca bir örneğini sunar. Senaryo, geçmiş veriler üzerinde eğitilen makine öğrenmesi algoritmalarıyla bir sahtekarlık algılama modeli oluşturur. Daha sonra gelecekteki sahte işlemleri algılamak için modeli kullanır.

Bu öğretici şu adımları kapsar:

  • Özel kitaplıkları yükleme
  • Verileri yükleme
  • Keşif veri analizi aracılığıyla verileri anlama ve işleme
  • Makine öğrenmesi modelini eğitmek için scikit-learn kullanma ve MLflow ve Doku Otomatik Kaydetme özellikleriyle denemeleri izleme
  • En yüksek performansa sahip makine öğrenmesi modelini kaydetme ve kaydetme
  • Puanlama ve tahminlerde bulunmak için makine öğrenmesi modelini yükleme

Önkoşullar

Not defterinde birlikte izleme

Not defterinde izleyebileceğiniz şu seçeneklerden birini belirleyebilirsiniz:

  • Veri Bilimi deneyiminde yerleşik not defterini açma ve çalıştırma
  • Not defterinizi GitHub'dan Veri Bilimi deneyimine yükleme

Yerleşik not defterini açma

Örnek Sahtekarlık algılama not defteri bu öğreticiye eşlik eder.

Synapse Veri Bilimi deneyiminde öğreticinin yerleşik örnek not defterini açmak için:

  1. Synapse Veri Bilimi giriş sayfasına gidin.

  2. Örnek kullan'ı seçin.

  3. İlgili örneği seçin:

    • Örnek bir Python öğreticisi içinse varsayılan uçtan uca iş akışları (Python) sekmesinden.
    • Örnek bir R öğreticisi içinse Uçtan uca iş akışları (R) sekmesinden.
    • Örnek hızlı bir öğretici içinse Hızlı öğreticiler sekmesinden.

  4. Kod çalıştırmaya başlamadan önce not defterine bir lakehouse ekleyin.

Not defterini GitHub'dan içeri aktarma

AIsample - Fraud Detection.ipynb not defteri bu öğreticiye eşlik eder.

Bu öğreticide eşlik eden not defterini açmak için, not defterini çalışma alanınıza aktarmak üzere Sisteminizi veri bilimi öğreticilerine hazırlama başlığındaki yönergeleri izleyin.

Bu sayfadaki kodu kopyalayıp yapıştırmayı tercih ederseniz, yeni bir not defteri oluşturabilirsiniz.

Kod çalıştırmaya başlamadan önce not defterine bir göl evi eklediğinizden emin olun.

1. Adım: Özel kitaplıkları yükleme

Makine öğrenmesi modeli geliştirme veya geçici veri analizi için Apache Spark oturumunuz için hızlı bir şekilde özel bir kitaplık yüklemeniz gerekebilir. Kitaplıkları yüklemek için iki seçeneğiniz vardır.

  • Yalnızca geçerli not defterinizde bir kitaplık yüklemek için not defterinizin satır içi yükleme özelliklerini (%pip veya %conda) kullanın.
  • Alternatif olarak, bir Doku ortamı oluşturabilir, ortak kaynaklardan kitaplıklar yükleyebilir veya özel kitaplıklar yükleyebilirsiniz ve çalışma alanı yöneticiniz ortamı çalışma alanı için varsayılan olarak ekleyebilir. Daha sonra ortamdaki tüm kitaplıklar çalışma alanındaki tüm not defterlerinde ve Spark iş tanımlarında kullanılabilir hale gelir. Ortamlar hakkında daha fazla bilgi için bkz . Microsoft Fabric'te ortam oluşturma, yapılandırma ve kullanma.

Bu öğreticide, kitaplığı not defterinize yüklemek imblearn için kullanın%pip install.

Not

PySpark çekirdeği çalıştırıldıktan sonra %pip install yeniden başlatılır. Diğer hücreleri çalıştırmadan önce gerekli kitaplıkları yükleyin.

# Use pip to install imblearn
%pip install imblearn

2. Adım: Verileri yükleme

Sahtekarlık algılama veri kümesi, Eylül 2013'ten itibaren Avrupalı kart sahiplerinin iki gün boyunca yaptığı kredi kartı işlemlerini içerir. Özgün özelliklere uygulanan Bir Asıl Bileşen Analizi (PCA) dönüştürmesi nedeniyle veri kümesi yalnızca sayısal özellikler içerir. PCA, ve Amountdışındaki Time tüm özellikleri dönüştürdü. Gizliliği korumak için özgün özellikleri veya veri kümesi hakkında daha fazla arka plan bilgisi sağlayamıyoruz.

Bu ayrıntılar veri kümesini açıklar:

  • V1, V2, , V3..., V28 özellikleri PCA ile elde edilen temel bileşenlerdir
  • Özellik, Time bir işlem ile veri kümesindeki ilk işlem arasındaki geçen saniyeleri içerir
  • Özellik Amount , işlem miktarıdır. Bu özelliği örneğin bağımlı, maliyete duyarlı öğrenme için kullanabilirsiniz
  • Sütun Class yanıt (hedef) değişkenidir. Sahtekarlık değerine 1 sahiptir, 0 aksi takdirde

Toplam 284.807 işlemden yalnızca 492'i sahtedir. Azınlık (sahte) sınıfı verilerin yalnızca %0,172'sini içerdiğinden veri kümesi oldukça dengesizdir.

Bu tabloda creditcard.csv verilerinin önizlemesi gösterilir:

Zaman 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 Miktar Sınıf
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"

Veri kümesini indirin ve lakehouse'a yükleyin

Bu not defterini farklı veri kümeleriyle kullanabilmek için bu parametreleri tanımlayın:

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

Bu kod, veri kümesinin genel kullanıma açık bir sürümünü indirir ve bir Fabric lakehouse'da depolar.

Önemli

Çalıştırmadan önce not defterine bir göl evi eklediğinizden emin olun. Aksi takdirde bir hata alırsınız.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

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

MLflow deneme izlemesini ayarlama

Deneme izleme işlemi, çalıştırdığınız her deneme için denemeyle ilgili tüm bilgileri kaydeder. Bazı durumlarda, belirli bir denemeyi çalıştırdığınızda daha iyi sonuçlar elde etmenin bir yolu yoktur. Böyle durumlarda, denemeyi durdurmalı ve yeni bir deneme yapmalısınız.

Microsoft Fabric'teki Synapse Veri Bilimi deneyimi bir otomatik kaydetme özelliği içerir. Bu özellik, eğitim sırasında makine öğrenmesi modelinin parametrelerini, ölçümlerini ve öğelerini otomatik olarak günlüğe kaydetmek için gereken kod miktarını azaltır. Bu özellik, MLflow otomatik kaydetme özelliklerini genişletir. Veri Bilimi deneyiminde derin tümleştirmeye sahiptir.

Otomatik kaydetme sayesinde, el ile izlemeye gerek kalmadan farklı modellerin ve denemelerin performansını kolayca izleyebilir ve karşılaştırabilirsiniz. Daha fazla bilgi için bkz . Microsoft Fabric'te otomatik olarak dağıtma.

Not defteri oturumunda Microsoft Fabric otomatik kaydetmeyi devre dışı bırakmak için öğesini çağırın mlflow.autolog() ve ayarlayın disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Göl evinden ham verileri okuma

Bu kod lakehouse'dan ham verileri okur:

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

3. Adım: Keşif veri analizi gerçekleştirme

Bu bölümde ilk olarak ham verileri ve üst düzey istatistikleri keşfedersiniz. Ardından verileri dönüştürmek için sütunları doğru türlere dönüştürün ve daha kolay görselleştirme için Spark DataFrame'den pandas DataFrame'e dönüştürün. Son olarak, verilerdeki sınıf dağıtımlarını keşfeder ve görselleştirirsiniz.

Ham verileri görüntüleme

  1. komutuyla display ham verileri keşfedin ve üst düzey istatistikleri görüntüleyin. Veri görselleştirme hakkında daha fazla bilgi için bkz . Microsoft Fabric'te not defteri görselleştirmesi.

    display(df)

  2. Veri kümesiyle ilgili bazı temel bilgileri yazdırın:

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

Verileri dönüştürme

  1. Veri kümesi sütunlarını doğru türlere dönüştür:

    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. Daha kolay görselleştirme ve işleme için Spark DataFrame'i pandas DataFrame'e dönüştürün:

    df_pd = df.toPandas()

Veri kümesindeki sınıf dağıtımını keşfetme

  1. Sınıf dağıtımını veri kümesinde görüntüleyin:

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

    Kod şu veri kümesi sınıfı dağılımını döndürür: %99,83 ve % No FraudsFrauds0,17 . Bu sınıf dağılımı, işlemlerin çoğunun dolandırılmadığını gösterir. Bu nedenle, fazla uygunluktan kaçınmak için model eğitiminden önce veri ön işleme gereklidir.

  2. Sahte ve sahte olmayan işlemlerin dağılımını görüntüleyerek veri kümesindeki sınıf dengesizliklerini göstermek için bir çizim kullanın:

    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. Kutu çizimleriyle işlem tutarı için beş sayılık özeti (en düşük puan, ilk dörttebirlik, ortanca, üçüncü dörttebirlik ve en yüksek puan) gösterin:

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

    Yüksek oranda dengesiz veriler için kutu çizimleri doğru içgörüler göstermeyebilir. Ancak, önce dengesizlik sorununu giderebilir Class ve ardından daha doğru içgörüler için aynı çizimleri oluşturabilirsiniz.

4. Adım: Modelleri eğitme ve değerlendirme

Burada, sahtekarlık işlemlerini sınıflandırmak için bir LightGBM modeli eğitebilirsiniz. LightGBM modelini hem dengesiz veri kümesinde hem de dengeli veri kümesinde eğitebilirsiniz. Ardından her iki modelin de performansını karşılaştırırsınız.

Eğitim ve test veri kümelerini hazırlama

Eğitimden önce verileri eğitim ve test veri kümelerine bölün:

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

Eğitim veri kümesine SMOTE uygulama

Kitaplık, imblearn dengesiz sınıflandırma sorununu gidermek için Yapay Azınlık Oversampling Technique (SMOTE) yaklaşımını kullanır. Dengesiz sınıflandırma, bir modelin karar sınırını etkili bir şekilde öğrenmesi için azınlık sınıfına çok az örnek sağlandığında gerçekleşir. SMOTE, azınlık sınıfı için yeni örnekleri sentezlemek için en yaygın kullanılan yaklaşımdır.

SMOTE'yi test veri kümesi yerine yalnızca eğitim veri kümesine uygulayın. Test verileriyle modeli puanladığınızda, üretimdeki görünmeyen verilerde model performansının yaklaşık olarak tahmin edilmesi gerekir. Geçerli bir tahmin için test verileriniz, üretim verilerini mümkün olduğunca yakından temsil etmek için özgün dengesiz dağıtıma dayanır.

# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE

X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))

new_train = pd.concat([X_res, y_res], axis=1)

SMOTE hakkında daha fazla bilgi için SMOTE yöntemi için scikit-learn başvuru sayfasına ve kaynakları fazla örneklemeye ilişkin scikit-learn kullanıcı kılavuzuna bakın.

Makine öğrenmesi modellerini eğitin ve denemeler çalıştırın

Microsoft Fabric'teki Apache Spark, büyük verilerle makine öğrenmesini etkinleştirir. Apache Spark ile büyük miktarlarda yapılandırılmış, yapılandırılmamış ve hızlı hareket eden verilerden değerli içgörüler elde edebilirsiniz.

Microsoft Fabric'te Apache Spark ile makine öğrenmesi modellerini eğitmek için kullanabileceğiniz çeşitli seçenekler vardır: Apache Spark MLlib, SynapseML ve diğer açık kaynak kitaplıklar. Daha fazla bilgi için bkz . Microsoft Fabric'te makine öğrenmesi modellerini eğitma.

Makine öğrenmesi denemesi , tüm ilgili makine öğrenmesi çalıştırmaları için birincil kuruluş ve denetim birimi görevi görür. Çalıştırma, model kodunun tek bir yürütülmesine karşılık gelir. Makine öğrenmesi denemesi izleme , parametreler, ölçümler, modeller ve diğer yapıtlar gibi tüm denemelerin ve bileşenlerinin yönetimini içerir.

Deneme izleme için belirli bir makine öğrenmesi denemesinin tüm gerekli bileşenlerini düzenleyebilirsiniz. Ayrıca, kaydedilmiş denemelerle geçmiş sonuçları kolayca yeniden oluşturabilirsiniz. Makine öğrenmesi denemeleri hakkında daha fazla bilgi için bkz . Microsoft Fabric'te makine öğrenmesi denemeleri.

  1. Daha fazla ölçümü, parametreyi ve dosyayı izlemek için MLflow otomatik kaydetme yapılandırmasını güncelleştirecek şekilde ayarlayın exclusive=False :

    mlflow.autolog(exclusive=False)

  2. LightGBM ile iki model eğitin. Modellerden biri dengesiz veri kümesini, diğer model ise dengeli veri kümesini (SMOTE aracılığıyla) işler. Ardından iki modelin performansını karşılaştırın.

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

Eğitim için özellik önemini belirleme

  1. Dengesiz veri kümesinde eğitmiş olduğunuz model için özellik önemini belirleyin:

    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. Dengeli veriler üzerinde eğitmiş olduğunuz model için özellik önemini belirleyin. SMOTE dengeli verileri oluşturdu:

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

Bir modeli dengesiz veri kümesiyle eğitmek için, dengeli veri kümesiyle eğitilen bir modelle karşılaştırıldığında önemli özellikler önemli farklılıklara sahiptir.

Modelleri değerlendirme

Burada, eğitilen iki modeli değerlendirirsiniz:

  • model ham, dengesiz veriler üzerinde eğitildi
  • smote_model dengeli veriler üzerinde eğitildi

İşlem modeli ölçümleri

  1. prediction_to_spark Tahmin gerçekleştiren ve tahmin sonuçlarını Spark DataFrame'e dönüştüren bir işlev tanımlayın. Daha sonra SynapseML ile tahmin sonuçlarıyla ilgili model istatistiklerini hesaplayabilirsiniz.

    from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType, DoubleType

def prediction_to_spark(model, test):
    predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
    predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
    dataColumns = [TARGET_COL, "prediction"]
    predictions = (
        spark.createDataFrame(data=predictions, schema=dataColumns)
        .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
        .withColumn("prediction", col("prediction").cast(DoubleType()))
    )

    return predictions

  2. prediction_to_spark İki model modelsmote_modelve ile tahminler gerçekleştirmek için işlevini kullanın:

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

  3. İki model için işlem ölçümleri:

    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)

Karışıklık matrisi ile model performansını değerlendirme

Karışıklık matrisi ,

  • gerçek pozitifler (TP)
  • gerçek negatifler (TN)
  • hatalı pozitifler (FP)
  • hatalı negatifler (FN)

bir modelin test verileriyle puanlandığında ürettiğini gösterir. İkili sınıflandırma için model bir 2x2 karışıklık matrisi döndürür. Çok sınıflı sınıflandırma için model, sınıfların sayısı olan n bir nxn karışıklık matrisi döndürür.

  1. Test verileri üzerinde eğitilen makine öğrenmesi modellerinin performanslarını özetlemek için karışıklık matrisi kullanın:

    # 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. Tahminleri smote_model için karışıklık matrisini çizin (dengeli veriler üzerinde eğitilir):

    # 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. Tahminleri model için karışıklık matrisini çizin (ham, dengesiz veriler üzerinde eğitilir):

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

AUC-ROC ve AUPRC ölçümleriyle model performansını değerlendirme

Eğri Alıcısı Çalışma Özelliğinin Altındaki Alan (AUC-ROC) ölçüsü, ikili sınıflandırıcıların performansını değerlendirir. AUC-ROC grafiği, gerçek pozitif oran (TPR) ile hatalı pozitif oran (FPR) arasındaki dengeyi görselleştirir.

Bazı durumlarda, sınıflandırıcınızı Duyarlık-Geri Çağırma Eğrisi (AUPRC) ölçüsü altındaki Alana göre değerlendirmek daha uygundur. AUPRC eğrisi şu oranları birleştirir:

  • Duyarlık veya pozitif tahmine dayalı değer (PPV)
  • Geri çekme veya TPR

AUC-ROC ve AUPRC ölçüleriyle performansı değerlendirmek için:

  1. AUC-ROC ve AUPRC ölçülerini döndüren bir işlev tanımlayın:

    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. Dengesiz veriler üzerinde eğitmiş olduğunuz model için AUC-ROC ve AUPRC ölçümlerini günlüğe kaydedin:

    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. Dengeli veriler üzerinde eğitmiş olduğunuz model için AUC-ROC ve AUPRC ölçümlerini günlüğe kaydedin:

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

Dengeli veriler üzerinde eğitilen model, dengesiz veriler üzerinde eğitilen modele kıyasla daha yüksek AUC-ROC ve AUPRC değerleri döndürür. Bu ölçülere dayanarak SMOTE, yüksek oranda dengesiz verilerle çalışırken model performansını geliştirmek için etkili bir teknik gibi görünüyor.

Sonraki görüntüde gösterildiği gibi, tüm denemeler ilgili adıyla günlüğe kaydedilir. Deneme parametrelerini ve performans ölçümlerini çalışma alanınızda izleyebilirsiniz.

Screenshot of the tracked experiment.

Bu görüntüde, dengeli veri kümesinde eğitilen modelin performans ölçümleri gösterilir (Sürüm 2'de):

Screenshot of logged model performance metrics and model parameters.

Dengesiz veri kümesinde eğitilen modelin ölçümlerini görmek için Sürüm 1'i seçebilirsiniz. Ölçümleri karşılaştırdığınızda, AUROC dengeli veri kümesiyle eğitilen model için daha yüksektir. Bu sonuçlar, bu modelin sınıfları olarak doğru tahmin etmede 0 ve sınıfları olarak 01tahmin etmede 1 daha iyi olduğunu gösterir.

5. Adım: Modelleri kaydetme

İki modeli kaydetmek için MLflow kullanın:

# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"

raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)

smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)

6. Adım: Tahmin sonuçlarını kaydetme

Microsoft Fabric, kullanıcıların makine öğrenmesi modellerini ölçeklenebilir işlevle PREDICT kullanıma hazır hale getirmesine olanak tanır. Bu işlev, herhangi bir işlem altyapısında toplu puanlama (veya toplu çıkarım) destekler.

Toplu tahminleri doğrudan Microsoft Fabric not defterinden veya modelin öğe sayfasından oluşturabilirsiniz. hakkında PREDICTdaha fazla bilgi için bkz . Microsoft Fabric'te PREDICT ile model puanlaması.

  1. Toplu puanlama için daha iyi performans gösteren modeli (Sürüm 2) yükleyin ve tahmin sonuçlarını oluşturun:

    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. Tahminleri göle kaydedin:

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

İlgili içerik