Kılavuz: Sahtekarlık tespiti modeli oluşturma, değerlendirme ve puanlama

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:

Önkoşullar

• bir Microsoft Fabric aboneliği alın. Ücretsiz Microsoft Fabric deneme sürümünekaydolun.

• Microsoft Fabriciçin oturum açın.

• Ana sayfanızın sol alt tarafındaki deneyim değiştiriciyi kullanarak Fabric'e geçin.

  

• Gerekirse, Microsoft Fabric'te göl evi (lakehouse) oluşturmabölümünde açıklandığı gibi bir Microsoft Fabric göl evi (lakehouse) oluşturun.

Bir not defterinde takip et.

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

• Yerleşik not defterini açın ve çalıştırın.
• GitHub'dan not defterinizi karşıya yükleyin.

Yerleşik not defterini açma

Örnek Sahtekarlık tespiti not defteri bu kılavuzla birlikte gelir.

1. Bu öğreticinin örnek not defterini açmak için Sisteminizi veri bilimi öğreticilerine hazırlamabaşlığındaki yönergeleri izleyin.

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

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 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 defteri bir göl evi eklemeyi unutmayın.

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.

• Not defterinizin yalnızca mevcut olanında bir kitaplık yüklemek için, not defterinizin satır içi yükleme yeteneklerini (%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 'da ortam oluşturma, yapılandırma ve kullanma.

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

# 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, Time ve Amountdışındaki 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
• Time özelliği, bir işlem ile veri kümesindeki ilk işlem arasındaki geçen saniyeleri içerir
• Amount özelliği işlem tutarıdır. Bu özelliği örneğin bağımlı, maliyete duyarlı öğrenme için kullanabilirsiniz
• Class sütunu yanıt (hedef) değişkenidir. Sahtekarlık için 1 değerine sahiptir, aksi takdirde 0 değerine sahiptir.

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

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

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.

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 entegrasyona 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 Kaydetme.

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

# Set up MLflow for experiment tracking
import mlflow

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

Lakehouse'tan ham verileri oku

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. display komutuyla 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 'daNot 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% No Frauds ve 0,17% Frauds. 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. İşlem tutarı için kutu çizimleriyle beş sayı özetini (minimum değer, birinci çeyrek, medyan, üçüncü çeyrek ve maksimum değer) 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 Class dengesizlik sorununu giderebilir 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 uygula

imblearn kitaplığı, dengesiz sınıflandırma sorununu gidermek için Sentetik Azınlık Fazla Örnekleme Tekniği (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ının fazla örneklemesine 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ğit.

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 deneme 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'de makine öğrenmesi denemeleri.

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

   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:

• ham, dengesiz ve işlenmemiş veriler üzerinde eğitilen model
• dengeli veriler üzerinde eğitilen smote_model

Model ölçümlerini hesapla

1. Tahmin gerçekleştiren ve tahmin sonuçlarını Spark DataFrame'e dönüştüren bir prediction_to_spark işlevi tanımlayın. Daha sonra SynapseMLile 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. model ve smote_modelolmak üzere iki modelle tahminler gerçekleştirmek için prediction_to_spark 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 sayılarını gösterir

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

bir modelin test verileriyle puanlandığında ürettiği sonuçları 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, nxn bir karışıklık matrisi döndürür, burada n sınıf sayısıdı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. smote_model tahminleri 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. model tahminleri 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çüleriyle 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 grafik, 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ı Precision-Recall Eğrisinin Altındaki Alan (AUPRC) ölçüsüne göre değerlendirmek daha uygundur. AUPRC eğrisi şu oranları birleştirir:

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

performansı AUC-ROC ve AUPRC ölçüleriyle 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 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 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.

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

Dengesiz veri kümesinde eğitilen modelin ölçümlerini görmek için Sürüm 1 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 0olarak 0 sınıflarını doğru tahmin etme ve 1olarak 1 sınıfları tahmin etme konusunda 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 PREDICT işlevle 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. PREDICThakkında daha fazla bilgi için bkz. Microsoft Fabric 'da 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

• Microsoft Fabric not defterlerini kullanma
• Microsoft Fabric'da makine öğrenmesi modeli
• makine öğrenmesi modellerini eğit
• Microsoft Fabric 'da makine öğrenmesi deneyleri