Samouczek: tworzenie, ocenianie i przypisywanie punktów modelowi wykrywania oszustw

Ten samouczek przedstawia pełny przykład przepływu pracy analizy danych usługi Synapse w usłudze Microsoft Fabric. Scenariusz tworzy model wykrywania oszustw przy użyciu algorytmów uczenia maszynowego wyszkolonych na danych historycznych. Następnie używa modelu do wykrywania przyszłych fałszywych transakcji.

W tym samouczku opisano następujące kroki:

• Instalowanie bibliotek niestandardowych
• Ładowanie danych
• Omówienie i przetwarzanie danych za pomocą eksploracyjnej analizy danych
• Użyj biblioteki scikit-learn do trenowania modelu uczenia maszynowego i śledzenia eksperymentów za pomocą funkcji autologowania MLflow i Fabric Autologging.
• Zapisywanie i rejestrowanie modelu uczenia maszynowego o najwyższej wydajności
• Ładowanie modelu uczenia maszynowego do oceniania i przewidywania

Warunki wstępne

• Pobierz subskrypcję usługi Microsoft Fabric . Możesz też utworzyć bezpłatne konto wersji próbnej usługi Microsoft Fabric.

• Zaloguj się do usługi Microsoft Fabric.

• Użyj przełącznika doświadczeń w lewej dolnej części strony głównej, aby przełączyć się na Fabric.

  

• W razie potrzeby utwórz magazyn lakehouse usługi Microsoft Fabric zgodnie z opisem w Tworzenie magazynu lakehouse w usłudze Microsoft Fabric.

Notuj w zeszycie

Możesz wybrać jedną z tych opcji, aby śledzić w zeszycie:

• Otwórz i uruchom wbudowany notes.
• Prześlij notebook z GitHub.

Otwieranie wbudowanego notesu

Przykładowy notatnik Wykrywanie oszustw jest dołączony do tego samouczka.

1. Aby otworzyć przykładowy notatnik na potrzeby tego samouczka, postępuj zgodnie z instrukcjami w sekcji Przygotuj swój system do samouczków nauki o danych.

2. Przed rozpoczęciem uruchamiania kodu upewnij się, że dołączyć magazyn lakehouse do notesu.

Importuj notebook z GitHub

Ten samouczek zawiera notes AIsample — Fraud Detection.ipynb.

• Aby otworzyć towarzyszący notatnik do tego samouczka, postępuj zgodnie z instrukcjami w sekcji Przygotuj system do samouczków z nauki o danych, aby zaimportować notatnik do swojego obszaru roboczego.

• Jeśli wolisz skopiować i wkleić kod z tej strony, możesz utworzyć nowy notes.

• Przed rozpoczęciem uruchamiania kodu pamiętaj, aby dołączyć magazyn lakehouse do notesu.

Krok 1. Instalowanie bibliotek niestandardowych

W przypadku tworzenia modeli uczenia maszynowego lub analizy danych ad hoc może być konieczne szybkie zainstalowanie biblioteki niestandardowej na potrzeby sesji platformy Apache Spark. Dostępne są dwie opcje instalowania bibliotek.

• Użyj możliwości instalacji w trybie inline (%pip lub %conda) w swoim notatniku, aby zainstalować bibliotekę tylko w bieżącym notatniku.
• Alternatywnie możesz utworzyć środowisko typu Fabric, zainstalować biblioteki ze źródeł publicznych lub przesłać do niego biblioteki niestandardowe, a następnie administrator obszaru roboczego może dołączyć środowisko jako domyślne dla obszaru roboczego. Wszystkie biblioteki w środowisku staną się następnie dostępne do użycia w dowolnych notesach i definicjach zadań platformy Spark w obszarze roboczym. Aby uzyskać więcej informacji na temat środowisk, zobacz tworzyć, konfigurować i używać środowisko w usłudze Microsoft Fabric.

Na potrzeby tego samouczka użyj %pip install, aby zainstalować bibliotekę imblearn w notesie.

Notatka

Jądro PySpark jest uruchamiane ponownie po uruchomieniu %pip install. Zainstaluj wymagane biblioteki przed uruchomieniem innych komórek.

# Use pip to install imblearn
%pip install imblearn

Krok 2. Ładowanie danych

Zestaw danych wykrywania oszustw zawiera transakcje kart kredytowych od września 2013 r., które europejskie posiadacze kart dokonali w ciągu dwóch dni. Zestaw danych zawiera tylko cechy liczbowe z powodu przekształcenia analizy głównych składników (PCA) zastosowanego do oryginalnych funkcji. Algorytm PCA przekształcił wszystkie cechy z wyjątkiem Time i Amount. Aby chronić poufność, nie możemy podać oryginalnych funkcji ani więcej podstawowych informacji o zestawie danych.

Te szczegóły opisują zestaw danych:

• Cechy V1, V2, V3, ..., V28 są głównymi składnikami uzyskanymi za pomocą PCA.
• Funkcja Time zawiera liczbę sekund między transakcją a pierwszą transakcją w zestawie danych
• Funkcja Amount to kwota transakcji. Można używać tej funkcji do uczenia zależnego od przykładów i kosztów.
• Kolumna Class to zmienna odpowiedzi (docelowa). Ma wartość 1 dla oszustwa, a 0 w przeciwnym razie.

Tylko 492 transakcje, z 284 807 transakcji łącznie, są fałszywe. Zestaw danych jest wysoce niezrównoważony, ponieważ mniejszość (oszukańcza) stanowi tylko około 0,172% danych.

W tej tabeli przedstawiono podgląd danych creditcard.csv:

Czas	Wersja 1	Wersja 2	Wersja 3	V4	Wersja 5	V6	Wersja 7	V8	Wersja 9	Wersja 10	Wersja 11	Wersja 12	Wersja 13	Wersja 14	Wersja 15	Wersja 16	Wersja 17	Wersja 18	Wersja 19	Wersja 20	Wersja 21	Wersja 22	Wersja 23	Wersja 24	V25	Wersja 26	Wersja 27	Wersja 28	Kwota	Klasa
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"

Pobierz zestaw danych i prześlij do Lakehouse

Zdefiniuj te parametry, aby można było używać tego notesu z różnymi zestawami danych:

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

Ten kod pobiera publicznie dostępną wersję zestawu danych, a następnie przechowuje ją w Fabric lakehouse.

Ważny

Przed uruchomieniem należy dodać lakehouse do notesu. W przeciwnym razie zostanie wyświetlony błąd.

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

Konfigurowanie śledzenia eksperymentów MLflow

Proces śledzenia eksperymentów zapisuje wszystkie istotne informacje dotyczące eksperymentu dla każdego uruchomionego eksperymentu. Czasami nie masz możliwości uzyskania lepszych wyników podczas uruchamiania określonego eksperymentu. W takich przypadkach należy zatrzymać eksperyment i wypróbować nowy.

Środowisko nauki o danych usługi Synapse w usłudze Microsoft Fabric zawiera funkcję automatycznego rejestrowania. Ta funkcja zmniejsza ilość kodu potrzebnego do automatycznego rejestrowania parametrów, metryk i elementów modelu uczenia maszynowego podczas trenowania. Funkcjonalność rozszerza możliwości automatycznego logowania MLflow. Ma głęboką integrację w środowisku nauki o danych.

Dzięki funkcji automatycznego rejestrowania można łatwo śledzić i porównywać wydajność różnych modeli i eksperymentów bez konieczności ręcznego śledzenia. Aby uzyskać więcej informacji, zobacz Autologowanie w Microsoft Fabric.

Aby wyłączyć autologowanie Microsoft Fabric w sesji notatnika, wywołaj mlflow.autolog() i ustaw disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Odczytywanie danych pierwotnych z lakehouse

Ten kod odczytuje nieprzetworzone dane z lakehouse:

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

Krok 3. Wykonywanie eksploracyjnej analizy danych

W tej sekcji najpierw zapoznasz się z nieprzetworzonymi danymi i statystykami wysokiego poziomu. Następnie, aby przekształcić dane, rzutuj kolumny na poprawne typy i przekonwertuj je z ramki danych Spark na ramkę danych biblioteki pandas, aby ułatwić wizualizację. Na koniec eksplorujesz i wizualizujesz rozkłady klas w danych.

Wyświetlanie danych pierwotnych

1. Zapoznaj się z danymi nieprzetworzonymi i wyświetl statystyki wysokiego poziomu za pomocą polecenia display. Aby uzyskać więcej informacji na temat wizualizacji danych, zobacz wizualizację notesu w usłudze Microsoft Fabric.

   display(df)
   

2. Wydrukuj kilka podstawowych informacji na temat zestawu danych:

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

Przekształcanie danych

1. Rzutowanie kolumn zestawu danych na poprawne typy:

   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. Przekonwertuj ramkę danych platformy Spark na ramkę danych biblioteki pandas, aby ułatwić wizualizację i przetwarzanie:

   df_pd = df.toPandas()
   

Eksplorowanie dystrybucji klas w zestawie danych

1. Wyświetl rozkład klas w zestawie danych:

   # 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 zwraca ten rozkład klas zestawu danych: 99,83% No Frauds i 0,17% Frauds. Ta dystrybucja klas pokazuje, że większość transakcji jest niefraudulentna. W związku z tym wstępne przetwarzanie danych jest wymagane przed trenowaniem modelu, aby uniknąć nadmiernego dopasowania.

2. Użyj wykresu, aby pokazać dysproporcję klas w zestawie danych, wyświetlając rozkład fałszywych i nieuprawnionej transakcji:

   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. Pokaż podsumowanie pięciu liczb (wynik minimalny, pierwszy kwartyl, mediana, trzeci kwartyl i maksymalny wynik) dla kwoty transakcji, korzystając z wykresów pudełkowych.

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

   W przypadku wysoce niezrównoważonych danych wykresy pól mogą nie pokazywać dokładnych szczegółowych informacji. Można jednak najpierw rozwiązać problem z nierównowagą Class, a następnie utworzyć te same wykresy, aby uzyskać dokładniejsze szczegółowe informacje.

Krok 4. Trenowanie i ocenianie modeli

W tym miejscu wytrenujesz model LightGBM, aby sklasyfikować transakcje oszustwa. Wytrenujesz model LightGBM zarówno na niezrównoważonym zestawie danych, jak i w zrównoważonym zestawie danych. Następnie porównasz wydajność obu modeli.

Przygotowywanie zestawów danych trenowania i testowania

Przed rozpoczęciem trenowania podziel dane na zestawy danych trenowania i testowania:

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

Stosowanie protokołu SMOTE do zestawu danych treningowych

Biblioteka imblearn korzysta z podejścia SMOTE (Synthetic Minority Oversampling Technique), aby zająć się problemem niezrównoważonej klasyfikacji. Niezrównoważona klasyfikacja występuje, gdy dostępnych jest zbyt mało przykładów klasy mniejszości, aby model mógł skutecznie nauczyć się określenia granicy decyzyjnej. SMOTE to najczęściej stosowane podejście do syntezowania nowych próbek dla klasy mniejszości.

Zastosuj metodę SMOTE tylko do zestawu danych treningowych, a nie do zestawu danych testowych. Podczas oceniania modelu przy użyciu danych testowych potrzebne jest przybliżenie wydajności modelu w przypadku niezaświetnionych danych w środowisku produkcyjnym. W celu uzyskania prawidłowego przybliżenia dane testowe opierają się na oryginalnym rozkładie nierównowagi, aby przedstawiać dane produkcyjne tak ściśle, jak to możliwe.

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

Aby uzyskać więcej informacji na temat narzędzia SMOTE, zobacz stronę referencyjną scikit-learn dla metody SMOTE oraz podręcznik użytkownika scikit-learn dotyczący zasobów oversampling.

Trenowanie modeli uczenia maszynowego i uruchamianie eksperymentów

Platforma Apache Spark w usłudze Microsoft Fabric umożliwia uczenie maszynowe przy użyciu danych big data. Platforma Apache Spark umożliwia uzyskiwanie cennych szczegółowych informacji z dużych ilości ustrukturyzowanych, nieustrukturyzowanych i szybko poruszających się danych.

Dostępnych jest kilka dostępnych opcji trenowania modeli uczenia maszynowego za pomocą platformy Apache Spark w usłudze Microsoft Fabric: Apache Spark MLlib, SynapseML i innych bibliotek typu open source. Aby uzyskać więcej informacji, zobacz Trenowanie modeli uczenia maszynowego w usłudze Microsoft Fabric.

Eksperyment uczenia maszynowego służy jako podstawowa jednostka organizacyjna i kontrolna dla wszystkich powiązanych przebiegów uczenia maszynowego. Uruchomienie odpowiada jednokrotnemu wykonaniu kodu modelu. Śledzenie eksperymentów uczenia maszynowego obejmuje zarządzanie wszystkimi eksperymentami i ich składnikami, takimi jak parametry, metryki, modele i inne artefakty.

W przypadku śledzenia eksperymentów można zorganizować wszystkie wymagane składniki określonego eksperymentu uczenia maszynowego. Ponadto można łatwo odtworzyć wcześniejsze wyniki za pomocą zapisanych eksperymentów. Aby uzyskać więcej informacji na temat eksperymentów uczenia maszynowego, zobacz Eksperymenty uczenia maszynowego w usłudze Microsoft Fabric.

1. Aby śledzić więcej metryk, parametrów i plików, ustaw exclusive=False w celu aktualizacji konfiguracji autologowania MLflow.

   mlflow.autolog(exclusive=False)
   

2. Trenowanie dwóch modeli za pomocą usługi LightGBM. Jeden model obsługuje niezrównoważony zestaw danych, a drugi model obsługuje zrównoważony zestaw danych (za pośrednictwem smOTE). Następnie porównaj wydajność dwóch modeli.

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

Określanie znaczenia funkcji na potrzeby trenowania

1. Określ znaczenie funkcji dla modelu, który został wytrenowany na niezrównoważonym zestawie danych:

   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. Określ znaczenie funkcji dla modelu, który został wytrenowany na podstawie zrównoważonych danych. SMOTE wygenerowało zrównoważone dane.

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

Aby wytrenować model z niezrównoważonym zestawem danych, ważne funkcje mają znaczące różnice w porównaniu z modelem wyszkolonym przy użyciu zrównoważonego zestawu danych.

Oceń modele

W tym miejscu ocenisz dwa wytrenowane modele:

• model trenowane na nieprzetworzonych, niezrównoważonych danych
• smote_model trenowane na podstawie zrównoważonych danych

Metryki modelu obliczeniowego

1. Zdefiniuj funkcję prediction_to_spark, która wykonuje przewidywania, i konwertuje wyniki przewidywania na ramkę danych platformy Spark. Następnie można obliczyć statystyki modelu na podstawie wyników przewidywania za pomocą 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. Użyj funkcji prediction_to_spark do wykonywania przewidywań z dwoma modelami, model i smote_model:

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

3. Metryki obliczeniowe dla dwóch modeli:

   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)
   

Ocena wydajności modelu za pomocą macierzy pomyłek

Macierz konfuzji wyświetla liczbę

• prawdziwie dodatnie (TP)
• prawdziwie ujemne (TN)
• wyniki fałszywie dodatnie (FP)
• fałszywie ujemne (FN)

model generuje wynik w przypadku oceny przy użyciu danych testowych. W przypadku klasyfikacji binarnej model zwraca macierz pomyłek 2x2. W klasyfikacji wieloklasowej model zwraca macierz pomyłek typu nxn, gdzie n oznacza liczbę klas.

1. Użyj macierzy pomyłek, aby podsumować wydajność wytrenowanych modeli uczenia maszynowego na danych testowych:

   # 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. Wykreśl macierz pomyłek dla przewidywań modelu smote_model (przeszkolonego na zrównoważonych danych):

   # 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. Wykreśl macierz pomyłek dla przewidywań model (wytrenowanych na nieprzetworzonych, niezrównoważonych danych):

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

Ocena wydajności modelu za pomocą miar AUC-ROC i AUPRC

Miernik Area Under the Curve Receiver Operating Characteristic (AUROC,AUC-ROC) ocenia skuteczność klasyfikatorów binarnych. Wykres AUC-ROC wizualizuje kompromis między prawdziwie dodatnim współczynnikiem (TPR) i współczynnikiem fałszywie dodatnim (FPR).

W niektórych przypadkach bardziej odpowiednie jest obliczenie klasyfikatora na podstawie miary Area Under the Precision-Recall Curve (AUPRC). Krzywa AUPRC łączy następujące współczynniki:

• Precyzja lub dodatnia wartość predykcyjna (PPV)
• Wycofanie lub TPR

Aby ocenić wydajność za pomocą miar AUC-ROC i AUPRC:

1. Zdefiniuj funkcję zwracającą miary AUC-ROC i 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. Zarejestruj metryki AUC-ROC i AUPRC dla modelu, który został wytrenowany na danych niezrównoważonych:

   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. Zarejestruj metryki AUC-ROC i AUPRC dla modelu, który został wytrenowany na podstawie zrównoważonych danych:

   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 wytrenowany na zrównoważonych danych zwraca wyższe wartości AUC-ROC i AUPRC w porównaniu z modelem wyszkolonym na niezrównoważonych danych. Na podstawie tych miar smOTE wydaje się skuteczną techniką zwiększania wydajności modelu podczas pracy z wysoce niezrównoważonymi danymi.

Jak pokazano na następnym obrazie, każdy eksperyment jest rejestrowany przy użyciu odpowiedniej nazwy. Parametry eksperymentu i metryki wydajności można śledzić w obszarze roboczym.

Na tym obrazie przedstawiono metryki wydajności dla modelu przeszkolonego na zrównoważonym zestawie danych (wersja 2).

Możesz wybrać wersję 1, aby wyświetlić metryki dla modelu wytrenowanego na niezrównoważonym zestawie danych. Podczas porównywania metryk model AUROC jest wyższy dla modelu trenowanego przy użyciu zrównoważonego zestawu danych. Te wyniki wskazują, że ten model jest lepszy w prawidłowym przewidywaniu klas 0 jako 0i przewidywaniu klas 1 jako 1.

Krok 5. Rejestrowanie modeli

Użyj platformy MLflow, aby zarejestrować dwa modele:

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

Krok 6. Zapisywanie wyników przewidywania

Usługa Microsoft Fabric umożliwia użytkownikom operacjonalizację modeli uczenia maszynowego przy użyciu funkcji skalowalnej PREDICT. Ta funkcja obsługuje ocenianie wsadowe (lub wnioskowanie wsadowe) w dowolnym silniku obliczeniowym.

Przewidywania wsadowe można wygenerować bezpośrednio z notesu usługi Microsoft Fabric lub na stronie elementu modelu. Aby uzyskać więcej informacji na temat PREDICT, zobacz Modele oceniania z PREDICT w Microsoft Fabric.

1. Załaduj model o lepszej wydajności (wersja 2) na potrzeby oceniania wsadowego i wygeneruj wyniki przewidywania:

   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. Zapisz przewidywania w jeziorze:

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

Powiązana zawartość

• Jak używać notatników Microsoft Fabric
• model uczenia maszynowego w usłudze Microsoft Fabric
• Trenowanie modeli uczenia maszynowego
• eksperymenty uczenia maszynowego w usłudze Microsoft Fabric