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

Bu öğretici, Microsoft Fabric'da Synapse Veri Bilimi iş akışının uçtan uca bir örneğini sunar. Senaryo, geçmiş veriler üzerinde eğitilen machine learning algoritmaları ile 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 ve MLflow ve Fabric Otomatik Kaydetme özellikleriyle denemeleri izlemek için scikit-learn kullanma
En iyi performansa sahip makine öğrenmesi modelini kaydet ve kaydet.
Puanlama ve tahminlerde bulunmak için machine learning modelini yükleme

Önkoşullar

Microsoft Fabric aboneliği alın. Alternatif olarak ücretsiz Microsoft Fabric deneme sürümüne kaydolabilirsiniz.
Microsoft Fabric oturum açın.
Giriş sayfanızın sol alt tarafındaki deneyim değiştiriciyi kullanarak Fabric'e geçiş yapın.

Gerekirse, Microsoft Fabric'te bir lakehouse oluşturun belgesinde açıklandığı gibi bir Microsoft Fabric lakehouse oluşturun.

Bir not defterinde takip et.

Not defterinde takip etmek için şu seçeneklerden birini belirleyin:

Yerleşik not defterini açın ve çalıştırın.
Not defterinizi GitHub yükleyin.

Yerleşik not defterini açma

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

Bu öğreticinin örnek not defterini açmak için Sisteminizi veri bilimi öğreticilerine hazırlamabaşlığındaki yönergeleri izleyin.
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

machine learning model 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 Fabric 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. Ortamdaki tüm kitaplıklar, çalışma alanı içindeki tüm not defterlerinde ve Spark iş tanımlarında kullanılabilir. Ortamlar hakkında daha fazla bilgi için bkz. Microsoft Fabric'de bir ortam oluşturma, yapılandırma ve kullanma.

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

Dikkat

%pip install çalıştırıldıktan sonra PySpark çekirdeği 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, Avrupalı kart sahiplerinin iki gün boyunca yaptıkları Eylül 2013 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 veri setinin orijinal özellikleri veya daha fazla arka plan bilgisi sunulamıyor.

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

V1, V2, , V3..., V28 özellikleri PCA ile elde edilen temel bileşenlerdir.
Bu özellik, Time 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:

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 Fabric bir göl evinde depolar.

Önemli

Not defterini çalıştırmadan önce bir göl evi ekleyin. 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.z13.web.core.windows.net/data/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

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

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 edemezsiniz. Bu gibi durumlarda denemeyi durdurun ve yenisini deneyin.

Microsoft Fabric'daki Synapse Veri Bilimi deneyimi bir otomatik kaydetme özelliği içerir. Bu özellik, eğitim sırasında bir makine öğrenimi modelinin parametrelerini, metriklerini 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 kaydetmeyi kullanarak, el ile izlemeye gerek kalmadan farklı modellerin ve denemelerin performansını kolayca izleyebilir ve karşılaştırabilirsiniz. Daha fazla bilgi için Autologging in Microsoft Fabric konusuna bakın.

Microsoft Fabric otomatik günlüğe kaydetmeyi bir not defteri oturumunda devre dışı bırakmak için mlflow.autolog()'ı çağırın ve disable=True ayarlayı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

komutunu kullanarak 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 Microsoft Fabric'de Notebook görselleştirmesi bölümüne bakın.
```
display(df)
```

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

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)

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

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.

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)

İş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

Bu adımda, sahtekarlık işlemlerini sınıflandırmak için bir LightGBM modeli eğitmiş olursunuz. 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)

machine learning modellerini eğitin ve denemeler çalıştırın

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

Microsoft Fabric 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'da makine öğrenmesi modellerini eğitme.

machine learning denemesi tüm ilgili machine learning ç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. Machine learning deney izleme, parametreler, ölçümler, modeller ve diğer artefaktlar gibi tüm denemelerin ve bileşenlerinin yönetimini içerir.

Deneme izleme için belirli bir machine learning 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'da Makine öğrenme denemeleri.

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

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

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

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ğittiğiniz zaman, önemli özellikler dengeli veri kümesiyle eğitilen bir modele kıyasla önemli farklılıklar gösterir.

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

prediction_to_spark Tahminler yapan ve tahmin sonuçlarını Spark DataFrame'e dönüştüren bir işlev tanımlayın. Daha sonra SynapseML kullanarak 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

prediction_to_spark işlevini model ve smote_model ile iki modelde tahmin yapmak için kullanın:

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

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

Test verilerinde eğitilen machine learning 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)

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

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:

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

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

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.

Aşağıdaki görüntüde gösterildiği gibi, sistem her denemeyi ilgili adıyla günlüğe kaydeder. Deneme parametrelerini ve performans ölçümlerini çalışma alanınızda izleyebilirsiniz.

Aşağıdaki görüntüde, dengeli veri kümesinde eğitilen modelin performans ölçümleri gösterilmektedir ( Sürüm 2'de):

Dengesiz veri kümesinde eğitilen modelin ölçümlerini görmek için Sürüm 1'i seçin. Ölçümleri karşılaştırdığınızda, AUROC'nin dengeli veri kümesiyle eğitilen model için daha yüksek olduğunu görürsünüz. 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 PREDICT ölçeklenebilir işlevini kullanarak makine öğrenmesi modellerini kullanıma hazır hale alabilir. 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. Microsoft Fabric'de PREDICT ile Model puanlaması hakkında daha fazla bilgi için bkz. .

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)

Tahminleri göle kaydedin:

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

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-04-07